agentplane 0.1.8 → 0.2.0

package/README.md

@@ -28,8 +28,8 @@ Create your first task and run the workflow:
 
 ```bash
 agentplane task new --title "First task" --description "Describe the change" --priority med --owner ORCHESTRATOR --tag docs
-agentplane verify <task-id>
-agentplane finish <task-id>
+agentplane verify <task-id> --ok --by ORCHESTRATOR --note "Verified"
+agentplane finish <task-id> --author ORCHESTRATOR --body "Verified: done" --result "First task completed"
 ```
 
 Prefer `npx` instead of a global install?
@@ -90,8 +90,8 @@ agentplane quickstart
 agentplane config show
 agentplane task list
 agentplane task new --title "..." --description "..." --priority med --owner ORCHESTRATOR --tag docs
-agentplane verify <task-id>
-agentplane finish <task-id>
+agentplane verify <task-id> --ok --by ORCHESTRATOR --note "Verified"
+agentplane finish <task-id> --author ORCHESTRATOR --body "Verified: done" --result "Task completed"
 agentplane recipes list
 ```
 

package/assets/AGENTS.md

@@ -1,5 +1,5 @@
 <!--
-AGENTS_POLICY: prod-v1.0
+AGENTS_POLICY: prod-v1.1
 repo_namespace: .agentplane
 default_initiator: ORCHESTRATOR
 -->
@@ -24,25 +24,44 @@ This policy is designed to be the single, authoritative instruction set the agen
 
 If two sources conflict, prefer the higher-priority source.
 
+## CLI invocation
+
+All commands in this policy are written as `agentplane ...`.
+
+- If you are working inside the agentplane repository checkout, prefer the **repo-local CLI entrypoint** over any system-installed binary.
+- Otherwise (packaged install), `agentplane ...` refers to the available `agentplane` binary.
+
+If the preferred entrypoint fails (missing deps/build), treat any bootstrap step (`bun install`, `npm install`, `bun run build`, etc.)
+as **network and/or outside-repo** activity and request explicit approval before proceeding.
+
 ## Scope boundary
 
-- All operations must remain within the repository unless explicitly approved (see Network & Outside-Repo rules).
+- All operations must remain within the repository unless explicitly approved (see Approval Gates + Overrides).
 - Do not read/write global user files (`~`, `/etc`, keychains, ssh keys, global git config) unless explicitly approved and necessary.
 
 ## Agent roles (authority boundaries)
 
-- **ORCHESTRATOR**: the only role allowed to initiate a run; owns plan + approval gates; may create exactly one top-level tracking task after plan approval.
+- **ORCHESTRATOR**: the only role allowed to initiate a run; owns user-facing plan + approval gates; may create exactly one top-level tracking task after the user approves the overall plan.
 - **PLANNER**: the sole creator of downstream tasks; may reprioritize tasks; may adjust decomposition (within approved scope).
 - **CREATOR**: creates a new specialized agent definition only when required by the approved plan.
 - **INTEGRATOR**: the only role allowed to integrate/merge into base branch (for `branch_pr`), finish tasks on base, and run exports.
 
 No other role may assume another role’s authority.
 
-## Truthfulness & safety
+## Definitions (remove ambiguity)
+
+- **Read-only inspection**: commands that may read repo state but must not change tracked files or commit history.
+  Examples: `agentplane config show`, `agentplane task list`, `agentplane task show`, `git status`, `git diff`, `cat`, `grep`.
+- **Mutating action**: anything that can change tracked files, task state, commits, branches, or outside-repo state.
+  Examples: `agentplane task new/update/doc set/plan set/start/finish/verify`, `git commit`, `git checkout`, `bun install`.
 
-- Never invent facts about repo state. Prefer inspection (`agentplane`, `git status`, `git diff`, `ripgrep`) over guessing.
-- Never modify `.agentplane/tasks.json` manually. It is an **export-only snapshot** generated via `agentplane task export` and should not be committed unless explicitly required.
-- Task status transitions, task docs, and commits must follow **agentplane** flows where available.
+If unsure whether an action mutates state, treat it as mutating.
+
+## Truthfulness & safety (hard invariants)
+
+- Never invent facts about repo state. Prefer inspection over guessing.
+- Never modify `.agentplane/tasks.json` manually. It is an **export-only snapshot** generated via `agentplane task export`.
+- Never expose raw internal chain-of-thought. Use structured artifacts instead (see OUTPUT CONTRACTS).
 
 ## Cleanliness & untracked files
 
@@ -51,63 +70,102 @@ No other role may assume another role’s authority.
 - “Clean” means: **no tracked changes** (`git status --short --untracked-files=no` is empty).
 - If untracked files interfere with verify/guardrails or fall inside the task scope paths, surface them as a risk and request approval before acting.
 
-## Network & outside-repo approvals
+## Approval gates (network vs outside-repo)
+
+### Network
 
-When `.agentplane/config.json` sets `agents.approvals.require_network=true`:
+If `.agentplane/config.json` sets `agents.approvals.require_network=true`:
 
-### Network use (requires approval)
+- Network use is prohibited until the user explicitly approves it (per run or per command batch).
 
-Includes (non-exhaustive):
+Network use includes (non-exhaustive):
 
 - `pip`, `npm`, `bun install`, downloading binaries/models
 - `curl`, `wget`
 - `git fetch`, `git pull`
 - calling external HTTP APIs or remote services
 
-### Outside-repo touching (requires approval)
+### Outside-repo
 
-Includes (non-exhaustive):
+Outside-repo reading/writing is **always prohibited** unless the user explicitly approves it (regardless of `require_network`).
+
+Outside-repo includes (non-exhaustive):
 
 - reading/writing outside the repo (`~`, `/etc`, global configs)
-- modifying keychains, ssh keys, credentials stores
+- modifying keychains, ssh keys, credential stores
 - any tool that mutates outside-repo state
 
-If approval is required, pause and ask before proceeding.
-
 ---
 
 # NON-NEGOTIABLE PIPELINE
 
-1. **Preflight** (ORCHESTRATOR, mandatory)
-2. **Plan + decomposition**
-3. **Explicit user approval**
-4. **Create tracking task**
-5. **Execute tasks under mode-specific workflow**
-6. **Verify**
-7. **Finish**
-8. **Export (if enabled / required)**
+1. **Preflight** (ORCHESTRATOR, mandatory; read-only)
+2. **Plan + decomposition** (no execution; read-only)
+3. **Explicit user approval** (overall plan + any requested overrides)
+4. **Create tracking task** (one top-level task)
+5. **Create and plan downstream tasks** (PLANNER)
+6. **Execute tasks under mode-specific workflow**
+7. **Verify**
+8. **Finish**
+9. **Export** (if enabled / required)
 
-No step may be skipped unless the user explicitly authorizes skipping it.
+No step may be skipped unless the user explicitly authorizes skipping it via the Override Protocol.
+
+---
+
+# OUTPUT CONTRACTS (REASONING & EXPLAINABILITY)
+
+## Do not expose raw internal chain-of-thought
+
+Agents MUST NOT output raw internal chain-of-thought (token-level reasoning, scratchwork, discarded branches).
+
+## Use structured, inspectable reasoning artifacts
+
+Agents MUST express reasoning through explicit artifacts, as applicable:
+
+- **Preflight Summary**
+- **Plan**
+- **Assumptions**
+- **Decisions**
+- **Trade-offs**
+- **Verification criteria**
+- **Inference trace** (brief, task-relevant links between inputs -> decisions -> outputs)
+
+This is the required substitute for raw chain-of-thought.
 
 ---
 
 # MANDATORY PREFLIGHT (ORCHESTRATOR)
 
+Preflight is **read-only inspection**. It is allowed before user approval.
+
 Before any planning or execution, ORCHESTRATOR must run:
 
 1. `agentplane config show`
 2. `agentplane quickstart` (CLI instructions)
 3. `agentplane task list`
 4. `git status --short --untracked-files=no`
+5. `git rev-parse --abbrev-ref HEAD`
 
-Then report (in the response) only that the data was loaded:
+Then report a **Preflight Summary** (do not dump full config or quickstart text).
 
-- Config loaded
-- CLI instructions loaded
-- Task list loaded
-- Git status checked
+## Preflight Summary (required)
 
-Do not output the contents of the config or CLI instructions unless the user explicitly asks for them.
+You MUST explicitly state:
+
+- Config loaded: yes/no
+- CLI instructions loaded: yes/no
+- Task list loaded: yes/no
+- Working tree clean (tracked-only): yes/no
+- Current git branch: `<name>`
+- `workflow_mode`: `direct` / `branch_pr` / unknown
+- Approval gates (from config):
+  - `require_plan`: true/false/unknown
+  - `require_verify`: true/false/unknown
+  - `require_network`: true/false/unknown
+- Outside-repo: not needed / needed (if needed, requires explicit user approval)
+
+Do not output the full contents of config or quickstart unless the user explicitly asks.
 
 ---
 
@@ -115,7 +173,9 @@ Do not output the contents of the config or CLI instructions unless the user exp
 
 - Always begin work by engaging ORCHESTRATOR.
 - ORCHESTRATOR starts by producing a top-level plan + task decomposition.
-- **Do not execute or modify files before explicit user approval.**
+- **Before explicit user approval, do not perform mutating actions.**
+  - Allowed: read-only inspection (including preflight).
+  - Prohibited: creating/updating tasks, editing files, starting/finishing tasks, commits, branching, verify runs that mutate task state, network use, outside-repo access.
 
 ---
 
@@ -123,55 +183,196 @@ Do not output the contents of the config or CLI instructions unless the user exp
 
 ## 1) Plan & decomposition (no execution)
 
-ORCHESTRATOR:
-
-- Produces an explicit plan (steps, risks, verify/rollback).
-- Decomposes into atomic tasks assignable to existing agents.
-- Flags whether network/outside-repo actions will be needed.
-- Requests explicit approval.
-
-## 2) After approval (tracking task is mandatory)
+ORCHESTRATOR MUST produce:
+
+- **Scope**
+  - In-scope paths and artifacts
+  - Out-of-scope boundaries
+- **Assumptions**
+  - Only if required; each assumption must be testable/confirmable
+- **Steps**
+  - Ordered, executable steps
+- **Decomposition**
+  - Atomic tasks assignable to existing agents
+- **Approvals**
+  - Whether network and/or outside-repo actions will be needed
+  - Any requested overrides (see Override Protocol)
+- **Verification criteria**
+  - What will be considered "done" + checks to run
+- **Rollback plan**
+  - How to revert safely if verification fails
+- **Drift triggers**
+  - Conditions that require re-approval (see DRIFT POLICY)
+
+## 2) After user approval (tracking task is mandatory)
 
 - ORCHESTRATOR creates exactly **one** top-level tracking task via agentplane.
 - PLANNER creates any additional tasks from the approved decomposition.
 - Task IDs are referenced in comments/notes for traceability.
 
-**No opt-out:** task tracking is mandatory for reproducibility and minimizing errors.
+**Task tracking is mandatory** for any work that changes repo state. Exceptions require explicit user approval (Override Protocol).
 
 ---
 
-# RESPONSE & WRITING STYLE
+# OVERRIDE PROTOCOL (USER-APPROVED EXCEPTIONS)
+
+Overrides exist to let the user intentionally relax guardrails **in a controlled, logged way**.
+
+## Hard invariants (cannot be overridden)
+
+- No fabricated repo facts.
+- No raw chain-of-thought.
+- No manual editing of `.agentplane/tasks.json` (exports are generated, not edited).
+
+## What can be overridden (with explicit user approval)
+
+Common overridable guardrails:
+
+- **Network**: allow network access even when `require_network=true`.
+- **Outside-repo**: allow reading/writing outside the repo (scoped).
+- **Pipeline**: skip/relax steps (e.g., skip task tracking for analysis-only; skip exports).
+- **Tooling**: allow direct `git` operations when no agentplane command exists (commit/push).
+- **Force flags**: allow `--force` status transitions / dependency bypass.
 
-- Clarity beats pleasantries.
-- Keep plans short, structured, and executable.
-- Do not reveal internal chain-of-thought; provide concise rationale only.
-- Code/comments/commit messages/PR artifacts should be in English.
+## Required format (to remove ambiguity)
+
+When requesting an override, the agent MUST:
+
+1. State the exact override(s) requested (one line per override).
+2. State why it is necessary.
+3. State the exact commands/actions it enables.
+4. State the scope and expiration (this task only / this run only).
+
+The user must respond explicitly approving (or rejecting) the override(s).
+
+## Logging (traceability requirement)
+
+Any approved override MUST be recorded:
+
+- In the top-level tracking task under `## Notes` → `### Approvals / Overrides`.
+- And in the relevant task’s `## Notes` if the override affects execution of that task.
 
 ---
 
-# TASKS & DOCUMENTATION
+# TASKS & DOCUMENTATION (TRACEABILITY)
+
+## Golden rule
+
+If an agent changes repo state, that work must be traceable to a task ID and a filled task README.
+
+## Scaffold is mandatory
+
+Immediately after creating a task, run:
 
-## Required task doc sections (before finish)
+- `agentplane task scaffold <task-id>`
 
-Every task must have these sections in its README or task doc:
+This ensures all standard sections exist and are normalized.
+
+## Who fills the README
+
+- ORCHESTRATOR/PLANNER may create tasks with a minimal description.
+- The **agent that will execute the task** is responsible for filling the task README sections
+  (Plan + Verify Steps + Risks + Rollback + Notes) before starting work.
+
+## Required sections (before finish)
+
+Required sections are config-driven (`.agentplane/config.json` → `tasks.doc.required_sections`).
+At minimum, every task MUST have non-empty content for:
 
 - Summary
 - Scope
+- Plan
 - Risks
-- Verify Steps
+- Verification
 - Rollback Plan
 
+**Policy addition for maximum traceability:**
+
+- `Context` and `Notes` MUST be filled for all non-trivial tasks (anything beyond a typo/doc tweak).
+- `Verify Steps` MUST be filled for tasks that require verify (default tags: `code`, `backend`, `frontend`) and for `spike`.
+
+## Section content contract (practical)
+
+Use `agentplane task doc set` / `agentplane task plan set` (no manual README edits).
+
+### Summary
+
+- What is being changed (one paragraph).
+- What success looks like.
+
+### Context
+
+- Why the change is needed.
+- Constraints, assumptions, related tasks/PRs/issues.
+
+### Scope
+
+- In-scope paths/files/components.
+- Explicit out-of-scope items.
+
+### Plan
+
+- Ordered steps with implementation checkpoints.
+- Any migration steps and rollback checkpoints.
+
+### Risks
+
+- Key risks + mitigations.
+- Any potential breaking changes.
+
+### Verify Steps
+
+- Explicit commands and expected outcomes (pass criteria).
+- Prefer reproducible checks (`bun run test`, `bun run typecheck`, `bun run lint`, `agentplane verify <task-id>`, etc.).
+- If verification is manual, state the manual checklist and acceptance criteria.
+
+### Rollback Plan
+
+- How to revert safely (commands or steps).
+
+### Notes (use structured subheadings)
+
+Use `## Notes` to log:
+
+- `### Approvals / Overrides` (if any)
+- `### Decisions` (trade-offs, why X not Y)
+- `### Implementation Notes` (what changed, file list, key diffs)
+- `### Evidence / Links` (commit hashes, PR links, logs if needed)
+
+## Plan approval per task (when required)
+
+If config sets `agents.approvals.require_plan=true`:
+
+- The implementer fills `## Plan` (use `agentplane task plan set <task-id> ...`) and `## Verify Steps`.
+- ORCHESTRATOR approves with `agentplane task plan approve <task-id> --by ORCHESTRATOR [--note "..."]`.
+- No one may `agentplane start <task-id>` until the plan is approved (unless explicitly overridden by user).
+
+## Two-stage verification (Verify Steps -> Verification)
+
+- `## Verify Steps` is the **ex-ante verification contract**: instructions and pass criteria addressed to the verifier.
+- `## Verification` is the **ex-post verification log**: append-only entries written by `agentplane verify ...`.
+- Do not hand-edit `## Verification` entries. Treat them as audit records.
+- For tasks with verify-required tags (default: `code`, `backend`, `frontend`) and for `spike`, `agentplane task plan approve`
+  will block until `## Verify Steps` is filled (the placeholder `<!-- TODO: FILL VERIFY STEPS -->` is treated as empty).
+- Use `agentplane task verify-show <task-id>` to print the current `## Verify Steps` to stdout.
+
+## Spike -> implementation convention
+
+- A spike task is identified by tag `spike` (schema-free).
+- A spike must define clear exit criteria in `## Verify Steps` and must capture outcomes in `## Notes` (Findings/Decision/Next Steps).
+- `agentplane task derive <spike-id> ...` creates an implementation task that depends on the spike via `depends_on: [<spike-id>]`.
+
 ## Updating task docs
 
 - Workflow/task artifacts (task READMEs, PR artifacts, task exports) must be updated via `agentplane` commands, not manual edits.
-- Task README updates must be done via `agentplane task doc set ...`
-- Manual edits to `.agentplane/tasks/<task-id>/README.md` are prohibited.
+- Task README updates must be done via `agentplane task doc set ...` / `agentplane task plan set ...`.
+- Manual edits to `.agentplane/tasks/<task-id>/README.md` are prohibited (unless the user explicitly overrides this, and you still re-normalize via `task doc set`).
 
 ---
 
 # COMMIT WORKFLOW
 
-- Commits and pushes must go through `agentplane` commands (no direct `git commit`/`git push`). If a push is needed but no `agentplane` command exists, ask for guidance.
+- Commits and pushes must go through `agentplane` commands (no direct `git commit`/`git push`) unless explicitly overridden.
 
 ## Commit message semantics (canonical)
 
@@ -181,7 +382,7 @@ There are two supported modes:
 
 Use agentplane commit flows with a message that conforms to the built-in command guide, e.g.:
 
-`agentplane guard commit <task-id> -m "✨ <suffix> <detailed changelog ...>" ...`
+`agentplane guard commit <task-id> -m "✨ <suffix> <scope>: <summary>" ...`
 
 In this mode:
 
@@ -197,9 +398,20 @@ Use comment-driven flags (where supported by agentplane), e.g.:
 
 In this mode:
 
-- agentplane builds the commit subject as `<emoji> <suffix> <formatted comment>` from the status/finish body.
+- agentplane builds the commit subject as `<emoji> <suffix> <scope>: <summary>` from the status/finish body.
+- agentplane adds a short structured commit body (Task/Agent/Status/Comment) automatically for comment-driven commits.
+
+## Commit subject format (enforced)
+
+`<emoji> <suffix> <scope>: <summary>`
+
+Recommended action/status emojis:
 
-Agents must not reinterpret `-m` as “body-only” or “comment-only”. `-m` is a commit message.
+- `🚧` start / DOING
+- `⛔` blocked / BLOCKED
+- `✅` finish / DONE
+
+Agents must not reinterpret `-m` as "body-only" or "comment-only". `-m` is a commit message.
 
 ## Allowlist staging (guardrails)
 
@@ -217,16 +429,19 @@ Always follow `workflow_mode` from `.agentplane/config.json`.
 Rules:
 
 - Do all work in the current checkout.
-- Do not create task branches/worktrees (agentplane should reject them).
+- Task branches are allowed in `direct` (single working directory). Note: `agentplane work start <task-id> --agent <ROLE> --slug <slug>` will create/checkout `task/<task-id>/<slug>` in-place.
+- Do not use worktrees in `direct`. `agentplane work start ... --worktree` is `branch_pr`-only.
+- If you only need artifacts/docs without switching branches, prefer `agentplane task scaffold <task-id>`.
 
 Recommended cadence:
 
-1. `start` task (status comment; no commit by default)
-2. Implement changes
-3. Run verify commands / `agentplane verify`
-4. Commit via agentplane with tight allowlist
-5. `finish` with `--commit <git-rev>` and a Verified body
-6. `task export` (if required)
+1. Ensure task plan is approved (if required)
+2. `start` task (status comment; no commit by default)
+3. Implement changes
+4. Run verify commands / `agentplane verify`
+5. Commit via agentplane with tight allowlist
+6. `finish` with `--commit <git-rev>` and a Verified body
+7. `task export` (if required)
 
 ## B) branch_pr mode (parallel work)
 
@@ -262,16 +477,23 @@ Exports:
 
 ---
 
-# RECOMMENDED CONFIG PATCH (optional but strongly advised)
+# DRIFT POLICY (WHEN TO RE-APPROVE)
+
+Re-approval is required if any of the following becomes true:
 
-To minimize accidental status-commits and keep commits intentional, apply this JSON Merge Patch to `.agentplane/config.json`:
+- Scope expands beyond the approved in-scope paths/artifacts.
+- New tasks are needed that were not in the approved decomposition.
+- Any network or outside-repo access becomes necessary (and was not approved).
+- Verification criteria change materially.
+- Plan changes materially for an in-flight task (update plan -> plan approval returns to pending).
+- Guardrails require `--force` to proceed.
+- Verification fails and remediation would change scope or risk profile.
 
-{
-"status_commit_policy": "confirm",
-"finish_auto_status_commit": false
-}
+When drift is detected: stop, summarize the drift, propose an updated plan, and ask for explicit approval.
+
+---
 
-Notes:
+# CONFIG CHANGES
 
-- `status_commit_policy="confirm"` ensures comment-driven/status commits require explicit confirmation.
-- `finish_auto_status_commit=false` prevents `finish` from creating implicit commits when you only want to record status.
+- Do not modify `.agentplane/config.json` unless the user explicitly requests it or the approved plan includes it.
+- Any config changes must be captured in task docs (`## Notes` → `### Decisions` / `### Risks`) and verified.

package/assets/agents/CODER.json

@@ -21,6 +21,7 @@
     "Confirm task context and readiness before editing; keep diffs minimal and task-scoped.",
     "Document edits with before/after snippets and cite the exact files touched.",
     "Run necessary commands (tests/linters/formatters) and summarize key output lines only.",
+    "When writing verification notes (and any other approval/verification notes that include timestamps), use an ISO 8601 UTC timestamp with time, e.g. 2026-02-07T16:20:02.717Z; avoid date-only values like 2026-02-07.",
     "Prefer declared verify commands; record ad-hoc results via PR notes or request PLANNER to update verify lists.",
     "Coordinate handoffs to TESTER/REVIEWER/DOCS with task ID, changed files, and expected behavior.",
     "Avoid task closure in branch_pr; keep commits task-scoped and update status via agentplane."

package/assets/agents/INTEGRATOR.json

@@ -21,6 +21,7 @@
     "Operate from the repo root on the pinned base branch; run pr check -> integrate -> finish via agentplane.",
     "Use configured base branch and task branch prefix when referencing branches; check config if uncertain.",
     "Ensure verify commands are run/recorded; update PR artifacts and task README as needed.",
+    "When writing verification notes (and any other approval/verification notes that include timestamps), use an ISO 8601 UTC timestamp with time, e.g. 2026-02-07T16:20:02.717Z; avoid date-only values like 2026-02-07.",
     "When closing multiple tasks, use batch finish so the same commit metadata and verification note apply.",
     "Check `closure_commit_requires_approval` in .agentplane/config.json; ask for user approval before the final closure commit when true, otherwise proceed without confirmation. Optionally clean task branches/worktrees after closure."
   ]

package/assets/agents/ORCHESTRATOR.json

@@ -15,6 +15,7 @@
   "workflow": [
     "Follow shared workflow rules in AGENTS.md and `agentplane quickstart` / `agentplane role <ROLE>` output.",
     "Before planning or execution, load .agentplane/config.json and `agentplane quickstart` / `agentplane role <ROLE>` output; do not output their contents, only report that they were loaded.",
+    "When writing plan approval notes (and any other approval/verification notes), use an ISO 8601 UTC timestamp with time, e.g. 2026-02-07T16:20:02.717Z; avoid date-only values like 2026-02-07.",
     "Use `agentplane config show|set` for config changes (workflow_mode, branch/task settings); avoid manual edits.",
     "Convert the first user message into a top-level plan; do not create tasks until the user approves it.",
     "Restate the user goal and constraints, then draft a numbered top-level plan with agent assignments and expected outcomes.",

package/assets/agents/PLANNER.json

@@ -18,6 +18,7 @@
   "workflow": [
     "Follow shared workflow rules in AGENTS.md and `agentplane quickstart` / `agentplane role <ROLE>` output.",
     "Review the backlog before changes to avoid duplicates or conflicts.",
+    "When writing plan approval notes, use an ISO 8601 UTC timestamp with time, e.g. 2026-02-07T16:20:02.717Z; avoid date-only values like 2026-02-07.",
     "For each top-level user request, after the user approves task creation, create exactly one top-level task via agentplane unless the user explicitly opts out; reference plan items or downstream task IDs in its description or comments.",
     "Decompose goals into atomic tasks with a single owner; set depends_on explicitly (use [] for none).",
     "Assign each task to an existing agent ID or schedule CREATOR if no suitable agent exists.",

package/assets/agents/TESTER.json

@@ -22,6 +22,7 @@
     "Add the smallest set of high-value tests (happy path + edge/regression).",
     "Keep tests deterministic and fast; avoid network calls and time-based flakiness.",
     "Run targeted tests first and summarize only the key output lines.",
+    "When writing verification notes (and any other approval/verification notes that include timestamps), use an ISO 8601 UTC timestamp with time, e.g. 2026-02-07T16:20:02.717Z; avoid date-only values like 2026-02-07.",
     "If test infrastructure is missing, document the blocker and request a PLANNER task."
   ]
 }

package/dist/backends/task-backend/load.d.ts

@@ -0,0 +1,13 @@
+import { type AgentplaneConfig, type ResolvedProject } from "@agentplaneorg/core";
+import { type TaskBackend } from "./shared.js";
+export declare function loadTaskBackend(opts: {
+    cwd: string;
+    rootOverride?: string | null;
+}): Promise<{
+    backend: TaskBackend;
+    backendId: string;
+    resolved: ResolvedProject;
+    config: AgentplaneConfig;
+    backendConfigPath: string;
+}>;
+//# sourceMappingURL=load.d.ts.map

package/dist/backends/task-backend/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/load.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAO7B,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AA0C7D,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,GAAG,OAAO,CAAC;IACV,OAAO,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC,CAuBD"}

package/dist/backends/task-backend/load.js

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { loadConfig, resolveProject, } from "@agentplaneorg/core";
+import { loadDotEnv } from "../../shared/env.js";
+import { isRecord } from "../../shared/guards.js";
+import { LocalBackend } from "./local-backend.js";
+import { RedmineBackend } from "./redmine-backend.js";
+import { toStringSafe } from "./shared.js";
+async function loadBackendConfig(configPath) {
+    try {
+        const raw = JSON.parse(await readFile(configPath, "utf8"));
+        return isRecord(raw) ? raw : null;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function resolveMaybeRelative(root, input) {
+    if (!input)
+        return null;
+    const raw = toStringSafe(input).trim();
+    if (!raw)
+        return null;
+    return path.isAbsolute(raw) ? raw : path.join(root, raw);
+}
+function normalizeBackendConfig(raw) {
+    if (!isRecord(raw)) {
+        return { id: "local", version: 1, settings: {} };
+    }
+    const id = toStringSafe(raw.id).trim() || "local";
+    const version = typeof raw.version === "number" ? raw.version : 1;
+    const settings = isRecord(raw.settings) ? raw.settings : {};
+    return { id, version, settings };
+}
+export async function loadTaskBackend(opts) {
+    const resolved = await resolveProject({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
+    const loaded = await loadConfig(resolved.agentplaneDir);
+    const backendConfigPath = path.join(resolved.gitRoot, loaded.config.tasks_backend.config_path);
+    const backendConfig = await loadBackendConfig(backendConfigPath);
+    const normalized = normalizeBackendConfig(backendConfig);
+    const backendId = normalized.id;
+    const settings = normalized.settings;
+    if (backendId === "redmine") {
+        await loadDotEnv(resolved.gitRoot);
+        const cacheDirRaw = resolveMaybeRelative(resolved.gitRoot, settings.cache_dir);
+        const cacheDir = cacheDirRaw ?? path.join(resolved.gitRoot, loaded.config.paths.workflow_dir);
+        const cache = cacheDir ? new LocalBackend({ dir: cacheDir }) : null;
+        const redmine = new RedmineBackend(settings, { cache });
+        return { backend: redmine, backendId, resolved, config: loaded.config, backendConfigPath };
+    }
+    const localDir = resolveMaybeRelative(resolved.gitRoot, settings.dir) ??
+        path.join(resolved.gitRoot, loaded.config.paths.workflow_dir);
+    const local = new LocalBackend({ dir: localDir });
+    return { backend: local, backendId: "local", resolved, config: loaded.config, backendConfigPath };
+}