wassname/pi-lgtm
1
0
Fork 0
mirror of https://github.com/wassname/pi-lgtm.git synced 2026-06-27 15:46:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

simplify proof logs and keep tasks repo-local

Browse Source
This commit is contained in:
wassname
2026-06-14 20:09:30 +08:00
parent 29c928c805
commit c0ceb95ea4
18 changed files with 5496 additions and 3683 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+8 -9
View File
@@ -13,7 +13,7 @@ A [pi](https://pi.dev) extension that adds proof-gated top-level tasks to task t
The core idea: subtasks are normal checklist items, but top-level tasks are goals. Agents cannot mark top-level tasks complete directly. They must call `TaskClaimDone` with auditable evidence, UAT hints, and explicit failure-mode analysis. A fresh judge then accepts or rejects the claim. Accepted review completes the task; rejected review leaves it open with suggestions.
Humans can use `/lgtm` to view the proof log and sanity-check the reviewer notes later. `/lgtm` is intentionally thin: proof viewing lives there, task management stays in `/tasks`.
Humans can use `/lgtm` to view the proof log and sanity-check the reviewer notes later. `/lgtm` is intentionally thin: proof viewing lives there, task management stays in `/tasks`. Long submitted-evidence blocks are previewed inline and truncated after about 16 lines, with the full artifact path shown in the proof log.
## Install
@@ -44,9 +44,8 @@ Stripped: `TaskExecute`, `TaskOutput`, `TaskStop`, `process-tracker.ts`, subagen
## Widget
```
● 3 tasks (1 done, 1 in progress, 1 open)
✔ #1 Design schema
✳ #2 Implementing cache layer… (2m 49s · ↑ 4.1k ↓ 1.2k)
● 3 goals (1 done hidden, 1 in progress, 1 open)
✳ #2 Implementing cache layer… (2m 49s, ↑ 4.1k ↓ 1.2k)
◻ #3 Load test
```
@@ -142,9 +141,9 @@ Interactive task-management menu: view tasks, create task, delete a selected tas
```text
Top-level task:
pending -> in_progress -> TaskClaimDone
-> current evidence iteration N 🛠
-> robot review iteration(s) 🤖
-> completed ✓ if latest robot review accepts
-> current evidence iteration N
-> robot review iteration(s)
-> completed if latest robot review accepts
-> remains open if reviewer rejects
-> completed if reviewer infrastructure fails (fail-open, note logged)
-> lgtm_supersede or newer TaskClaimDone -> superseded history + fresh current evidence
@@ -168,7 +167,7 @@ Override via env:
```bash
PI_TASKS=off # in-memory (CI)
PI_TASKS=sprint-1 # named shared list at ~/.pi/tasks/sprint-1.json
PI_TASKS=sprint-1 # named project-local list at .pi/tasks/sprint-1.json
PI_TASKS=/abs/path # explicit path
PI_TASKS_DEBUG=1 # trace to stderr
```
@@ -178,7 +177,7 @@ PI_TASKS_DEBUG=1 # trace to stderr
```text
src/
├── index.ts # tools + /tasks + /lgtm evidence viewer + widget + event handlers
├── review-badges.ts # Review badge helpers for evidence/review/completion lanes
├── review-badges.ts # Review state helpers for proof/completion lanes
├── robot-review.ts # Robot review iteration storage + compatibility helpers
├── types.ts # Task, TaskStatus types
├── task-store.ts # File-backed store with CRUD, locking, complete() method
src/auto-clear.ts
+70 -66
View File
@@ -13,79 +13,83 @@ import type { TaskStore } from "./task-store.js";
export type AutoClearMode = "never" | "on_list_complete" | "on_task_complete";
export class AutoClearManager {
/** Per-task: turn when task was marked completed ("on_task_complete" mode). */
private completedAtTurn = new Map<string, number>();
/** Turn when ALL tasks became completed ("on_list_complete" mode). */
private allCompletedAtTurn: number | null = null;
/** Per-task: turn when task was marked completed ("on_task_complete" mode). */
private completedAtTurn = new Map<string, number>();
/** Turn when ALL tasks became completed ("on_list_complete" mode). */
private allCompletedAtTurn: number | null = null;
constructor(
private getStore: () => TaskStore,
private getMode: () => AutoClearMode,
/** How many turns completed tasks linger before auto-clearing. */
private clearDelayTurns = 4,
) {}
constructor(
private getStore: () => TaskStore,
private getMode: () => AutoClearMode,
/** How many turns completed tasks linger before auto-clearing. */
private clearDelayTurns = 4,
) {}
/** Record a task completion. Call AFTER cascade logic. */
trackCompletion(taskId: string, currentTurn: number): void {
const mode = this.getMode();
if (mode === "never") return;
/** Record a task completion. Call AFTER cascade logic. */
trackCompletion(taskId: string, currentTurn: number): void {
const mode = this.getMode();
if (mode === "never") return;
if (mode === "on_task_complete") {
this.completedAtTurn.set(taskId, currentTurn);
} else if (mode === "on_list_complete") {
this.checkAllCompleted(currentTurn);
}
}
if (mode === "on_task_complete") {
this.completedAtTurn.set(taskId, currentTurn);
} else if (mode === "on_list_complete") {
this.checkAllCompleted(currentTurn);
}
}
/** Check if all tasks are completed and start/reset the batch countdown. */
private checkAllCompleted(currentTurn: number): void {
const tasks = this.getStore().list();
if (tasks.length > 0 && tasks.every(t => t.status === "completed")) {
if (this.allCompletedAtTurn === null) this.allCompletedAtTurn = currentTurn;
} else {
this.allCompletedAtTurn = null;
}
}
/** Check if all tasks are completed and start/reset the batch countdown. */
private checkAllCompleted(currentTurn: number): void {
const tasks = this.getStore().list();
if (tasks.length > 0 && tasks.every((t) => t.status === "completed")) {
if (this.allCompletedAtTurn === null)
this.allCompletedAtTurn = currentTurn;
} else {
this.allCompletedAtTurn = null;
}
}
/** Reset batch countdown (e.g., when a new task is created or task goes non-completed). */
resetBatchCountdown(): void {
this.allCompletedAtTurn = null;
}
/** Reset batch countdown (e.g., when a new task is created or task goes non-completed). */
resetBatchCountdown(): void {
this.allCompletedAtTurn = null;
}
/** Reset all tracking state (e.g., on new session). */
reset(): void {
this.completedAtTurn.clear();
this.allCompletedAtTurn = null;
}
/** Reset all tracking state (e.g., on new session). */
reset(): void {
this.completedAtTurn.clear();
this.allCompletedAtTurn = null;
}
/**
* Called on each turn start. Deletes tasks whose linger period has expired.
* Returns true if any tasks were cleared.
*/
onTurnStart(currentTurn: number): boolean {
const mode = this.getMode();
let cleared = false;
/**
* Called on each turn start. Deletes tasks whose linger period has expired.
* Returns true if any tasks were cleared.
*/
onTurnStart(currentTurn: number): boolean {
const mode = this.getMode();
let cleared = false;
if (mode === "on_task_complete") {
for (const [taskId, turn] of this.completedAtTurn) {
const task = this.getStore().get(taskId);
if (!task || task.status !== "completed") {
// Task was deleted or reverted — drop stale tracking entry
this.completedAtTurn.delete(taskId);
} else if (currentTurn - turn >= this.clearDelayTurns) {
this.getStore().delete(taskId);
this.completedAtTurn.delete(taskId);
cleared = true;
}
}
} else if (mode === "on_list_complete" && this.allCompletedAtTurn !== null) {
if (currentTurn - this.allCompletedAtTurn >= this.clearDelayTurns) {
this.getStore().clearCompleted();
this.allCompletedAtTurn = null;
cleared = true;
}
}
if (mode === "on_task_complete") {
for (const [taskId, turn] of this.completedAtTurn) {
const task = this.getStore().get(taskId);
if (!task || task.status !== "completed") {
// Task was deleted or reverted — drop stale tracking entry
this.completedAtTurn.delete(taskId);
} else if (currentTurn - turn >= this.clearDelayTurns) {
this.getStore().delete(taskId);
this.completedAtTurn.delete(taskId);
cleared = true;
}
}
} else if (
mode === "on_list_complete" &&
this.allCompletedAtTurn !== null
) {
if (currentTurn - this.allCompletedAtTurn >= this.clearDelayTurns) {
this.getStore().clearCompleted();
this.allCompletedAtTurn = null;
cleared = true;
}
}
return cleared;
}
return cleared;
}
}
src/index.ts
+2174 -1324
View File
File diff suppressed because it is too large Load Diff
src/review-badges.ts
+63 -76
View File
@@ -1,99 +1,86 @@
import { getLatestRobotReview, getRobotReviews } from "./robot-review.js";
import { getLatestRobotReview } from "./robot-review.js";
import type { Task } from "./types.js";
const STAGES = ["🛠", "🤖", "✓"] as const;
function hasCurrentEvidence(task: Task): boolean {
return typeof task.metadata?.lgtm_evidence === "string" && task.metadata.lgtm_evidence.length > 0;
return (
typeof task.metadata?.lgtm_evidence === "string" &&
task.metadata.lgtm_evidence.length > 0
);
}
function hasEvidenceHistory(task: Task): boolean {
return Array.isArray(task.metadata?.lgtm_history) && task.metadata.lgtm_history.length > 0;
return (
Array.isArray(task.metadata?.lgtm_history) &&
task.metadata.lgtm_history.length > 0
);
}
/** Pipeline stages: `[🛠·🤖·✓]` fills left-to-right as evidence→review→completed progresses. */
export function getReviewBadges(task: Task): string {
const filled = [
!!task.metadata?.lgtm_evidence,
getRobotReviews(task).length > 0,
task.status === "completed",
];
const slots = STAGES.map((emoji, i) => filled[i] ? emoji : "·");
return `[${slots.join("")}]`;
}
export const REVIEW_BADGES = {
evidence: STAGES[0],
robot: STAGES[1],
complete: STAGES[2],
pipeline: STAGES,
};
export type DisplayStatus = "in_progress" | "pending" | "completed";
export function getDisplayStatus(task: Task): DisplayStatus {
return task.status;
return task.status;
}
export type CompletionMode = "direct" | "proof";
export type ReviewState =
| "no_claim"
| "claim_submitted"
| "reviewer_failed_to_run"
| "reviewer_rejected"
| "reviewer_accepted"
| "superseded"
| "completed";
export type StateTag = "ACTIVE" | "PENDING" | "DONE";
| "no_claim"
| "claim_submitted"
| "reviewer_failed_to_run"
| "reviewer_rejected"
| "reviewer_accepted"
| "superseded"
| "completed";
export function getCompletionMode(task: Task): CompletionMode {
return task.parentId ? "direct" : "proof";
return task.parentId ? "direct" : "proof";
}
export function getReviewState(task: Task): ReviewState {
if (task.status === "completed") return "completed";
const latest = getLatestRobotReview(task);
if (latest && !latest.accepted) return "reviewer_rejected";
if (latest?.accepted) return "reviewer_accepted";
if (typeof task.metadata?.robot_review_last_error === "string") return "reviewer_failed_to_run";
if (hasCurrentEvidence(task)) return "claim_submitted";
if (hasEvidenceHistory(task)) return "superseded";
return "no_claim";
if (task.status === "completed") return "completed";
const latest = getLatestRobotReview(task);
if (latest && !latest.accepted) return "reviewer_rejected";
if (latest?.accepted) return "reviewer_accepted";
if (typeof task.metadata?.robot_review_last_error === "string")
return "reviewer_failed_to_run";
if (hasCurrentEvidence(task)) return "claim_submitted";
if (hasEvidenceHistory(task)) return "superseded";
return "no_claim";
}
export function needsProofAttention(task: Task): boolean {
if (task.parentId || task.status === "completed") return false;
const state = getReviewState(task);
return (
state === "reviewer_rejected" ||
state === "reviewer_accepted" ||
state === "reviewer_failed_to_run"
);
}
export function getGateStatus(task: Task): string {
const state = getReviewState(task);
if (task.parentId) {
return task.status === "completed" ? "completed directly as subtask" : "subtask: direct completion allowed";
}
if (task.status === "completed") {
if (typeof task.metadata?.robot_review_last_error === "string") {
return `completed with reviewer unavailable: ${task.metadata.robot_review_last_error}`;
}
if (getLatestRobotReview(task)?.accepted) return "completed after accepted proof review";
return "completed";
}
if (state === "no_claim") return "top-level task requires TaskClaimDone evidence before completion";
if (state === "reviewer_accepted") return "review accepted; task should be completed";
if (state === "reviewer_failed_to_run") {
return `review unavailable; autonomy continues: ${task.metadata.robot_review_last_error}`;
}
if (state === "reviewer_rejected") return "latest proof review rejected the evidence; strengthen the proof and try again";
if (state === "superseded") return "current evidence superseded, waiting for a new proof claim";
return "proof claim submitted, automatic review still required";
}
/** Short uppercase tag for compact task-list display. */
export function getStateTag(task: Task): StateTag {
const s = getDisplayStatus(task);
if (s === "completed") return "DONE";
if (s === "in_progress") return "ACTIVE";
return "PENDING";
}
/** Theme colour key for each state tag (only theme colours present in pi-tui are used). */
export function getStateTagColor(tag: StateTag): "accent" | "dim" | undefined {
if (tag === "ACTIVE") return "accent";
if (tag === "DONE") return "dim";
return undefined; // PENDING — default fg
const state = getReviewState(task);
if (task.parentId) {
return task.status === "completed"
? "completed directly as subtask"
: "subtask: direct completion allowed";
}
if (task.status === "completed") {
if (typeof task.metadata?.robot_review_last_error === "string") {
return `completed with reviewer unavailable: ${task.metadata.robot_review_last_error}`;
}
if (getLatestRobotReview(task)?.accepted)
return "completed after accepted proof review";
return "completed";
}
if (state === "no_claim")
return "top-level task requires TaskClaimDone evidence before completion";
if (state === "reviewer_accepted")
return "review accepted; task should be completed";
if (state === "reviewer_failed_to_run") {
return `review unavailable; autonomy continues: ${task.metadata.robot_review_last_error}`;
}
if (state === "reviewer_rejected")
return "latest proof review rejected the evidence; strengthen the proof and try again";
if (state === "superseded")
return "current evidence superseded, waiting for a new proof claim";
return "proof claim submitted, automatic review still required";
}
src/robot-review.ts
+267 -151
View File
@@ -3,185 +3,301 @@ import type { Task } from "./types.js";
export type RobotReviewMode = "manual" | "auto";
export interface RobotReviewRecord {
iteration: number;
reviewer: string;
scope: string;
observations: string[];
concerns: string[];
suggestions: string[];
blind_spots: string;
accepted: boolean;
evidence_complete: boolean;
evidence_convincing: boolean;
missing_evidence: string[];
submitted_at: string;
mode: RobotReviewMode;
raw_output?: string;
rubric?: Record<string, { reason: string; pass: boolean }>;
iteration: number;
reviewer: string;
scope: string;
observations: string[];
concerns: string[];
suggestions: string[];
blind_spots: string;
accepted: boolean;
evidence_complete: boolean;
evidence_convincing: boolean;
missing_evidence: string[];
submitted_at: string;
mode: RobotReviewMode;
raw_output?: string;
rubric?: Record<string, { reason: string; pass: boolean }>;
}
function toStringArray(value: unknown): string[] {
return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
return Array.isArray(value)
? value.filter((item): item is string => typeof item === "string")
: [];
}
function extractRubric(value: unknown): Record<string, { reason: string; pass: boolean }> | undefined {
if (!value || typeof value !== "object") return undefined;
const r: Record<string, { reason: string; pass: boolean }> = {};
for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
if (val && typeof val === "object" && "reason" in (val as any) && "pass" in (val as any)) {
const v = val as { reason: unknown; pass: unknown };
r[key] = { reason: typeof v.reason === "string" ? v.reason : "", pass: v.pass === true };
}
}
return Object.keys(r).length > 0 ? r : undefined;
function extractRubric(
value: unknown,
): Record<string, { reason: string; pass: boolean }> | undefined {
if (!value || typeof value !== "object") return undefined;
const r: Record<string, { reason: string; pass: boolean }> = {};
for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
if (
val &&
typeof val === "object" &&
"reason" in (val as any) &&
"pass" in (val as any)
) {
const v = val as { reason: unknown; pass: unknown };
r[key] = {
reason: typeof v.reason === "string" ? v.reason : "",
pass: v.pass === true,
};
}
}
return Object.keys(r).length > 0 ? r : undefined;
}
function normalizeReview(value: unknown, index: number): RobotReviewRecord | undefined {
if (!value || typeof value !== "object") return undefined;
const review = value as Record<string, unknown>;
const reviewer = typeof review.reviewer === "string" ? review.reviewer : "unknown";
const scope = typeof review.scope === "string" ? review.scope : "unknown";
const observations = toStringArray(review.observations);
if (observations.length === 0) return undefined;
return {
iteration: typeof review.iteration === "number" ? review.iteration : index + 1,
reviewer,
scope,
observations,
concerns: toStringArray(review.concerns),
suggestions: toStringArray(review.suggestions),
blind_spots: typeof review.blind_spots === "string" ? review.blind_spots : "not recorded",
accepted: typeof review.accepted === "boolean"
? review.accepted
: (typeof review.evidence_complete === "boolean" ? review.evidence_complete : true)
&& (typeof review.evidence_convincing === "boolean" ? review.evidence_convincing : true),
evidence_complete: typeof review.evidence_complete === "boolean" ? review.evidence_complete : true,
evidence_convincing: typeof review.evidence_convincing === "boolean" ? review.evidence_convincing : true,
missing_evidence: toStringArray(review.missing_evidence),
submitted_at: typeof review.submitted_at === "string" ? review.submitted_at : new Date(0).toISOString(),
mode: review.mode === "auto" ? "auto" : "manual",
raw_output: typeof review.raw_output === "string" ? review.raw_output : undefined,
rubric: extractRubric(review.rubric),
};
function normalizeReview(
value: unknown,
index: number,
): RobotReviewRecord | undefined {
if (!value || typeof value !== "object") return undefined;
const review = value as Record<string, unknown>;
const reviewer =
typeof review.reviewer === "string" ? review.reviewer : "unknown";
const scope = typeof review.scope === "string" ? review.scope : "unknown";
const observations = toStringArray(review.observations);
if (observations.length === 0) return undefined;
return {
iteration:
typeof review.iteration === "number" ? review.iteration : index + 1,
reviewer,
scope,
observations,
concerns: toStringArray(review.concerns),
suggestions: toStringArray(review.suggestions),
blind_spots:
typeof review.blind_spots === "string"
? review.blind_spots
: "not recorded",
accepted:
typeof review.accepted === "boolean"
? review.accepted
: (typeof review.evidence_complete === "boolean"
? review.evidence_complete
: true) &&
(typeof review.evidence_convincing === "boolean"
? review.evidence_convincing
: true),
evidence_complete:
typeof review.evidence_complete === "boolean"
? review.evidence_complete
: true,
evidence_convincing:
typeof review.evidence_convincing === "boolean"
? review.evidence_convincing
: true,
missing_evidence: toStringArray(review.missing_evidence),
submitted_at:
typeof review.submitted_at === "string"
? review.submitted_at
: new Date(0).toISOString(),
mode: review.mode === "auto" ? "auto" : "manual",
raw_output:
typeof review.raw_output === "string" ? review.raw_output : undefined,
rubric: extractRubric(review.rubric),
};
}
function getLegacyRobotReview(task: Task): RobotReviewRecord | undefined {
const observations = toStringArray(task.metadata?.robot_review_observations);
if (observations.length === 0) return undefined;
return {
iteration: 1,
reviewer: typeof task.metadata?.robot_review_reviewer === "string" ? task.metadata.robot_review_reviewer : "unknown",
scope: typeof task.metadata?.robot_review_scope === "string" ? task.metadata.robot_review_scope : "unknown",
observations,
concerns: toStringArray(task.metadata?.robot_review_concerns),
suggestions: toStringArray(task.metadata?.robot_review_suggestions),
blind_spots: typeof task.metadata?.robot_review_blind_spots === "string" ? task.metadata.robot_review_blind_spots : "not recorded",
accepted: typeof task.metadata?.robot_review_accepted === "boolean"
? task.metadata.robot_review_accepted
: (typeof task.metadata?.robot_review_evidence_complete === "boolean" ? task.metadata.robot_review_evidence_complete : true)
&& (typeof task.metadata?.robot_review_evidence_convincing === "boolean" ? task.metadata.robot_review_evidence_convincing : true),
evidence_complete: typeof task.metadata?.robot_review_evidence_complete === "boolean" ? task.metadata.robot_review_evidence_complete : true,
evidence_convincing: typeof task.metadata?.robot_review_evidence_convincing === "boolean" ? task.metadata.robot_review_evidence_convincing : true,
missing_evidence: toStringArray(task.metadata?.robot_review_missing_evidence),
submitted_at: typeof task.metadata?.robot_review_submitted_at === "string" ? task.metadata.robot_review_submitted_at : new Date(0).toISOString(),
mode: task.metadata?.robot_review_mode === "auto" ? "auto" : "manual",
raw_output: typeof task.metadata?.robot_review_raw_output === "string" ? task.metadata.robot_review_raw_output : undefined,
};
const observations = toStringArray(task.metadata?.robot_review_observations);
if (observations.length === 0) return undefined;
return {
iteration: 1,
reviewer:
typeof task.metadata?.robot_review_reviewer === "string"
? task.metadata.robot_review_reviewer
: "unknown",
scope:
typeof task.metadata?.robot_review_scope === "string"
? task.metadata.robot_review_scope
: "unknown",
observations,
concerns: toStringArray(task.metadata?.robot_review_concerns),
suggestions: toStringArray(task.metadata?.robot_review_suggestions),
blind_spots:
typeof task.metadata?.robot_review_blind_spots === "string"
? task.metadata.robot_review_blind_spots
: "not recorded",
accepted:
typeof task.metadata?.robot_review_accepted === "boolean"
? task.metadata.robot_review_accepted
: (typeof task.metadata?.robot_review_evidence_complete === "boolean"
? task.metadata.robot_review_evidence_complete
: true) &&
(typeof task.metadata?.robot_review_evidence_convincing === "boolean"
? task.metadata.robot_review_evidence_convincing
: true),
evidence_complete:
typeof task.metadata?.robot_review_evidence_complete === "boolean"
? task.metadata.robot_review_evidence_complete
: true,
evidence_convincing:
typeof task.metadata?.robot_review_evidence_convincing === "boolean"
? task.metadata.robot_review_evidence_convincing
: true,
missing_evidence: toStringArray(
task.metadata?.robot_review_missing_evidence,
),
submitted_at:
typeof task.metadata?.robot_review_submitted_at === "string"
? task.metadata.robot_review_submitted_at
: new Date(0).toISOString(),
mode: task.metadata?.robot_review_mode === "auto" ? "auto" : "manual",
raw_output:
typeof task.metadata?.robot_review_raw_output === "string"
? task.metadata.robot_review_raw_output
: undefined,
};
}
export function getRobotReviews(task: Task): RobotReviewRecord[] {
const reviews = Array.isArray(task.metadata?.robot_reviews)
? task.metadata.robot_reviews
.map((review: unknown, index: number) => normalizeReview(review, index))
.filter((review): review is RobotReviewRecord => review !== undefined)
: [];
if (reviews.length > 0) {
return reviews.map((review, index) => ({ ...review, iteration: index + 1 }));
}
const legacy = getLegacyRobotReview(task);
return legacy ? [legacy] : [];
const reviews = Array.isArray(task.metadata?.robot_reviews)
? task.metadata.robot_reviews
.map((review: unknown, index: number) => normalizeReview(review, index))
.filter((review): review is RobotReviewRecord => review !== undefined)
: [];
if (reviews.length > 0) {
return reviews.map((review, index) => ({
...review,
iteration: index + 1,
}));
}
const legacy = getLegacyRobotReview(task);
return legacy ? [legacy] : [];
}
export function getLatestRobotReview(task: Task): RobotReviewRecord | undefined {
const reviews = getRobotReviews(task);
return reviews.length > 0 ? reviews[reviews.length - 1] : undefined;
export function getLatestRobotReview(
task: Task,
): RobotReviewRecord | undefined {
const reviews = getRobotReviews(task);
return reviews.length > 0 ? reviews[reviews.length - 1] : undefined;
}
function hasNonEmptyString(value: unknown): boolean {
return typeof value === "string" && value.trim().length > 0;
return typeof value === "string" && value.trim().length > 0;
}
export function hasCompleteProofClaim(task: Task): boolean {
const metadata = task.metadata ?? {};
return [
metadata.lgtm_evidence,
metadata.lgtm_failure_likely,
metadata.lgtm_failure_sneaky,
metadata.lgtm_failure_unknown,
metadata.lgtm_falsification_test,
metadata.lgtm_evidence_reasoning,
metadata.lgtm_remaining_uncertainty,
].every(hasNonEmptyString)
&& Array.isArray(metadata.lgtm_verification_hints)
&& metadata.lgtm_verification_hints.some(hasNonEmptyString);
const metadata = task.metadata ?? {};
return (
[
metadata.lgtm_evidence,
metadata.lgtm_failure_likely,
metadata.lgtm_failure_sneaky,
metadata.lgtm_failure_unknown,
metadata.lgtm_falsification_test,
metadata.lgtm_evidence_reasoning,
metadata.lgtm_remaining_uncertainty,
].every(hasNonEmptyString) &&
Array.isArray(metadata.lgtm_verification_hints) &&
metadata.lgtm_verification_hints.some(hasNonEmptyString)
);
}
export function shouldCompleteAfterAcceptedReview(task: Task, reviewAccepted: boolean): boolean {
return reviewAccepted && hasCompleteProofClaim(task);
export function shouldCompleteAfterAcceptedReview(
task: Task,
reviewAccepted: boolean,
): boolean {
return reviewAccepted && hasCompleteProofClaim(task);
}
export function relaxAdvisoryVerificationHints(review: Omit<RobotReviewRecord, "iteration">): Omit<RobotReviewRecord, "iteration"> {
const rubric = review.rubric;
if (!rubric || review.evidence_complete !== true) return review;
const requiredCoreKeys = ["evidence_covers_done_criterion", "falsification_test_runnable", "failure_modes_addressed", "evidence_distinguishes_success"];
if (!requiredCoreKeys.every((key) => rubric[key]?.pass === true)) return review;
const failedKeys = Object.entries(rubric)
.filter(([, item]) => item.pass !== true)
.map(([key]) => key);
if (failedKeys.length !== 1 || failedKeys[0] !== "verification_hints_actionable") return review;
return {
...review,
accepted: true,
evidence_convincing: true,
observations: [
...review.observations,
"Verification hints were weak, but treated as advisory because the verbatim evidence already covered the done criterion.",
],
concerns: review.concerns,
suggestions: review.suggestions,
missing_evidence: review.missing_evidence.filter((item) => item !== "verification_hints_actionable" && !/verification hint/i.test(item)),
};
export function relaxAdvisoryVerificationHints(
review: Omit<RobotReviewRecord, "iteration">,
): Omit<RobotReviewRecord, "iteration"> {
const rubric = review.rubric;
if (!rubric || review.evidence_complete !== true) return review;
const requiredCoreKeys = [
"evidence_covers_done_criterion",
"falsification_test_runnable",
];
if (!requiredCoreKeys.every((key) => rubric[key]?.pass === true))
return review;
const failedKeys = Object.entries(rubric)
.filter(([, item]) => item.pass !== true)
.map(([key]) => key);
const advisoryKeys = [
"failure_modes_addressed",
"evidence_distinguishes_success",
"verification_hints_actionable",
];
if (
failedKeys.length === 0 ||
!failedKeys.every((key) => advisoryKeys.includes(key))
)
return review;
const advisoryNotes: string[] = [];
if (failedKeys.includes("failure_modes_addressed")) {
advisoryNotes.push(
"Failure-mode writeup was weak, but treated as advisory because the verbatim evidence already covered the done criterion.",
);
}
if (failedKeys.includes("evidence_distinguishes_success")) {
advisoryNotes.push(
"Why-this-proves-it reasoning was weak, but treated as advisory because the packet already contained direct success evidence.",
);
}
if (failedKeys.includes("verification_hints_actionable")) {
advisoryNotes.push(
"Verification hints were weak, but treated as advisory because the verbatim evidence already covered the done criterion.",
);
}
return {
...review,
accepted: true,
evidence_convincing: true,
observations: [...review.observations, ...advisoryNotes],
concerns: review.concerns,
suggestions: review.suggestions,
missing_evidence: review.missing_evidence.filter(
(item) =>
!advisoryKeys.includes(item) &&
!/verification hint/i.test(item) &&
!/failure[- ]?mode/i.test(item) &&
!/distinguish/i.test(item),
),
};
}
export function appendRobotReviewMetadata(task: Task, review: Omit<RobotReviewRecord, "iteration">): Record<string, unknown> {
const robot_reviews = [...getRobotReviews(task), { ...review, iteration: 0 }].map((entry, index) => ({
...entry,
accepted: entry.accepted,
iteration: index + 1,
}));
const latest = robot_reviews[robot_reviews.length - 1];
return {
robot_reviews,
robot_review_reviewer: latest.reviewer,
robot_review_scope: latest.scope,
robot_review_observations: latest.observations,
robot_review_concerns: latest.concerns,
robot_review_suggestions: latest.suggestions,
robot_review_blind_spots: latest.blind_spots,
robot_review_accepted: latest.accepted,
robot_review_evidence_complete: latest.evidence_complete,
robot_review_evidence_convincing: latest.evidence_convincing,
robot_review_missing_evidence: latest.missing_evidence,
robot_review_submitted_at: latest.submitted_at,
robot_review_mode: latest.mode,
robot_review_raw_output: latest.raw_output ?? null,
robot_review_requires_followup: !(latest.evidence_complete && latest.evidence_convincing),
robot_review_iteration_count: robot_reviews.length,
};
export function appendRobotReviewMetadata(
task: Task,
review: Omit<RobotReviewRecord, "iteration">,
): Record<string, unknown> {
const robot_reviews = [
...getRobotReviews(task),
{ ...review, iteration: 0 },
].map((entry, index) => ({
...entry,
accepted: entry.accepted,
iteration: index + 1,
}));
const latest = robot_reviews[robot_reviews.length - 1];
return {
robot_reviews,
robot_review_reviewer: latest.reviewer,
robot_review_scope: latest.scope,
robot_review_observations: latest.observations,
robot_review_concerns: latest.concerns,
robot_review_suggestions: latest.suggestions,
robot_review_blind_spots: latest.blind_spots,
robot_review_accepted: latest.accepted,
robot_review_evidence_complete: latest.evidence_complete,
robot_review_evidence_convincing: latest.evidence_convincing,
robot_review_missing_evidence: latest.missing_evidence,
robot_review_submitted_at: latest.submitted_at,
robot_review_mode: latest.mode,
robot_review_raw_output: latest.raw_output ?? null,
robot_review_requires_followup: !(
latest.evidence_complete && latest.evidence_convincing
),
robot_review_iteration_count: robot_reviews.length,
};
}
export function latestRobotReviewPasses(task: Task): boolean {
const latest = getLatestRobotReview(task);
return latest ? latest.accepted : false;
const latest = getLatestRobotReview(task);
return latest ? latest.accepted : false;
}
src/task-store.ts
+297 -204
View File
@@ -2,248 +2,341 @@
* task-store.ts — File-backed task store with CRUD, dependency management, and file locking.
*
* Session-scoped (default): in-memory Map — no disk I/O.
* Shared (PI_TASK_LIST_ID set): ~/.pi/tasks/<listId>.json with file locking.
* Named or project stores live under <cwd>/.pi/tasks/ unless an absolute path is given.
*/
import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import {
existsSync,
mkdirSync,
readFileSync,
renameSync,
unlinkSync,
writeFileSync,
} from "node:fs";
import { dirname, isAbsolute, join } from "node:path";
import type { Task, TaskStatus, TaskStoreData } from "./types.js";
const TASKS_DIR = join(homedir(), ".pi", "tasks");
const TASKS_DIR = join(process.cwd(), ".pi", "tasks");
const LOCK_RETRY_MS = 50;
const LOCK_MAX_RETRIES = 100; // 5s max
function acquireLock(lockPath: string): void {
for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
try {
writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
return;
} catch (e: any) {
if (e.code === "EEXIST") {
try {
const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
if (pid && !isProcessRunning(pid)) { unlinkSync(lockPath); continue; }
} catch { /* ignore */ }
const start = Date.now();
while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
continue;
}
throw e;
}
}
throw new Error(`Failed to acquire lock: ${lockPath}`);
for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
try {
writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
return;
} catch (e: any) {
if (e.code === "EEXIST") {
try {
const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
if (pid && !isProcessRunning(pid)) {
unlinkSync(lockPath);
continue;
}
} catch {
/* ignore */
}
const start = Date.now();
while (Date.now() - start < LOCK_RETRY_MS) {
/* busy wait */
}
continue;
}
throw e;
}
}
throw new Error(`Failed to acquire lock: ${lockPath}`);
}
function releaseLock(lockPath: string): void {
try { unlinkSync(lockPath); } catch { /* ignore */ }
try {
unlinkSync(lockPath);
} catch {
/* ignore */
}
}
function isProcessRunning(pid: number): boolean {
try { process.kill(pid, 0); return true; } catch { return false; }
try {
process.kill(pid, 0);
return true;
} catch {
return false;
}
}
export class TaskStore {
private filePath: string | undefined;
private lockPath: string | undefined;
private nextId = 1;
private tasks = new Map<string, Task>();
private filePath: string | undefined;
private lockPath: string | undefined;
private nextId = 1;
private tasks = new Map<string, Task>();
constructor(listIdOrPath?: string) {
if (!listIdOrPath) return;
const isAbsPath = isAbsolute(listIdOrPath);
const filePath = isAbsPath ? listIdOrPath : join(TASKS_DIR, `${listIdOrPath}.json`);
mkdirSync(dirname(filePath), { recursive: true });
this.filePath = filePath;
this.lockPath = filePath + ".lock";
this.load();
}
constructor(listIdOrPath?: string) {
if (!listIdOrPath) return;
const isAbsPath = isAbsolute(listIdOrPath);
const filePath = isAbsPath
? listIdOrPath
: join(TASKS_DIR, `${listIdOrPath}.json`);
mkdirSync(dirname(filePath), { recursive: true });
this.filePath = filePath;
this.lockPath = filePath + ".lock";
this.load();
}
private load(): void {
if (!this.filePath || !existsSync(this.filePath)) return;
try {
const data: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
this.nextId = data.nextId;
this.tasks.clear();
for (const t of data.tasks) this.tasks.set(t.id, t);
} catch { /* corrupt file — start fresh */ }
}
private load(): void {
if (!this.filePath || !existsSync(this.filePath)) return;
try {
const data: TaskStoreData = JSON.parse(
readFileSync(this.filePath, "utf-8"),
);
this.nextId = data.nextId;
this.tasks.clear();
for (const t of data.tasks) this.tasks.set(t.id, t);
} catch {
/* corrupt file — start fresh */
}
}
private save(): void {
if (!this.filePath) return;
const tmpPath = this.filePath + ".tmp";
writeFileSync(tmpPath, JSON.stringify({ nextId: this.nextId, tasks: Array.from(this.tasks.values()) }, null, 2));
renameSync(tmpPath, this.filePath);
}
private save(): void {
if (!this.filePath) return;
const tmpPath = this.filePath + ".tmp";
writeFileSync(
tmpPath,
JSON.stringify(
{ nextId: this.nextId, tasks: Array.from(this.tasks.values()) },
null,
2,
),
);
renameSync(tmpPath, this.filePath);
}
private withLock<T>(fn: () => T): T {
if (!this.lockPath) return fn();
acquireLock(this.lockPath);
try { this.load(); const result = fn(); this.save(); return result; }
finally { releaseLock(this.lockPath); }
}
private withLock<T>(fn: () => T): T {
if (!this.lockPath) return fn();
acquireLock(this.lockPath);
try {
this.load();
const result = fn();
this.save();
return result;
} finally {
releaseLock(this.lockPath);
}
}
create(subject: string, description: string, done_criterion: string, progress_label?: string, metadata?: Record<string, any>, parentId?: string): Task {
return this.withLock(() => {
if (parentId && !this.tasks.has(parentId)) throw new Error(`Parent task #${parentId} not found`);
const now = Date.now();
const task: Task = {
id: String(this.nextId++),
subject, description, done_criterion,
parentId,
status: "pending",
progress_label,
metadata: metadata ?? {},
blocks: [], blockedBy: [],
createdAt: now, updatedAt: now,
};
this.tasks.set(task.id, task);
return task;
});
}
create(
subject: string,
description: string,
done_criterion: string,
progress_label?: string,
metadata?: Record<string, any>,
parentId?: string,
): Task {
return this.withLock(() => {
if (parentId && !this.tasks.has(parentId))
throw new Error(`Parent task #${parentId} not found`);
const now = Date.now();
const task: Task = {
id: String(this.nextId++),
subject,
description,
done_criterion,
parentId,
status: "pending",
progress_label,
metadata: metadata ?? {},
blocks: [],
blockedBy: [],
createdAt: now,
updatedAt: now,
};
this.tasks.set(task.id, task);
return task;
});
}
get(id: string): Task | undefined {
if (this.filePath) this.load();
return this.tasks.get(id);
}
get(id: string): Task | undefined {
if (this.filePath) this.load();
return this.tasks.get(id);
}
list(): Task[] {
if (this.filePath) this.load();
return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
}
list(): Task[] {
if (this.filePath) this.load();
return Array.from(this.tasks.values()).sort(
(a, b) => Number(a.id) - Number(b.id),
);
}
update(id: string, fields: {
status?: TaskStatus | "deleted";
subject?: string;
description?: string;
done_criterion?: string;
progress_label?: string;
metadata?: Record<string, any>;
parentId?: string | null;
add_blocks?: string[];
add_blocked_by?: string[];
}): { task: Task | undefined; changedFields: string[]; warnings: string[] } {
return this.withLock(() => {
const task = this.tasks.get(id);
if (!task) return { task: undefined, changedFields: [], warnings: [] };
update(
id: string,
fields: {
status?: TaskStatus | "deleted";
subject?: string;
description?: string;
done_criterion?: string;
progress_label?: string;
metadata?: Record<string, any>;
parentId?: string | null;
add_blocks?: string[];
add_blocked_by?: string[];
},
): { task: Task | undefined; changedFields: string[]; warnings: string[] } {
return this.withLock(() => {
const task = this.tasks.get(id);
if (!task) return { task: undefined, changedFields: [], warnings: [] };
const changedFields: string[] = [];
const warnings: string[] = [];
const changedFields: string[] = [];
const warnings: string[] = [];
// Subtasks are normal checklist items. Top-level tasks are goals and need a proof
// claim plus automatic review; TaskClaimDone is the only agent path that completes them.
if (fields.status === "completed" && !task.parentId) {
throw new Error(`Top-level task #${id} requires proof. Use TaskClaimDone with evidence and failure modes; subtasks can be completed directly.`);
}
// Subtasks are normal checklist items. Top-level tasks are goals and need a proof
// claim plus automatic review; TaskClaimDone is the only agent path that completes them.
if (fields.status === "completed" && !task.parentId) {
throw new Error(
`Top-level task #${id} requires proof. Use TaskClaimDone with evidence and failure modes; subtasks can be completed directly.`,
);
}
if (fields.status === "deleted") {
this.tasks.delete(id);
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter(bid => bid !== id);
t.blockedBy = t.blockedBy.filter(bid => bid !== id);
}
return { task: undefined, changedFields: ["deleted"], warnings: [] };
}
if (fields.status === "deleted") {
this.tasks.delete(id);
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter((bid) => bid !== id);
t.blockedBy = t.blockedBy.filter((bid) => bid !== id);
}
return { task: undefined, changedFields: ["deleted"], warnings: [] };
}
if (fields.status !== undefined) { task.status = fields.status as TaskStatus; changedFields.push("status"); }
if (fields.subject !== undefined) { task.subject = fields.subject; changedFields.push("subject"); }
if (fields.description !== undefined) { task.description = fields.description; changedFields.push("description"); }
if (fields.done_criterion !== undefined) { task.done_criterion = fields.done_criterion; changedFields.push("done_criterion"); }
if (fields.progress_label !== undefined) { task.progress_label = fields.progress_label; changedFields.push("progress_label"); }
if (fields.status !== undefined) {
task.status = fields.status as TaskStatus;
changedFields.push("status");
}
if (fields.subject !== undefined) {
task.subject = fields.subject;
changedFields.push("subject");
}
if (fields.description !== undefined) {
task.description = fields.description;
changedFields.push("description");
}
if (fields.done_criterion !== undefined) {
task.done_criterion = fields.done_criterion;
changedFields.push("done_criterion");
}
if (fields.progress_label !== undefined) {
task.progress_label = fields.progress_label;
changedFields.push("progress_label");
}
if (fields.metadata !== undefined) {
for (const [key, value] of Object.entries(fields.metadata)) {
if (value === null) delete task.metadata[key];
else task.metadata[key] = value;
}
changedFields.push("metadata");
}
if (fields.metadata !== undefined) {
for (const [key, value] of Object.entries(fields.metadata)) {
if (value === null) delete task.metadata[key];
else task.metadata[key] = value;
}
changedFields.push("metadata");
}
if (fields.parentId !== undefined) {
throw new Error("parentId is creation-only. Create subtasks with TaskCreate(parentId); do not downgrade top-level proof goals.");
}
if (fields.parentId !== undefined) {
throw new Error(
"parentId is creation-only. Create subtasks with TaskCreate(parentId); do not downgrade top-level proof goals.",
);
}
if (fields.add_blocks?.length) {
for (const targetId of fields.add_blocks) {
if (!task.blocks.includes(targetId)) task.blocks.push(targetId);
const target = this.tasks.get(targetId);
if (target && !target.blockedBy.includes(id)) { target.blockedBy.push(id); target.updatedAt = Date.now(); }
if (targetId === id) warnings.push(`#${id} blocks itself`);
else if (!target) warnings.push(`#${targetId} does not exist`);
else if (target.blocks.includes(id)) warnings.push(`cycle: #${id} and #${targetId} block each other`);
}
changedFields.push("blocks");
}
if (fields.add_blocks?.length) {
for (const targetId of fields.add_blocks) {
if (!task.blocks.includes(targetId)) task.blocks.push(targetId);
const target = this.tasks.get(targetId);
if (target && !target.blockedBy.includes(id)) {
target.blockedBy.push(id);
target.updatedAt = Date.now();
}
if (targetId === id) warnings.push(`#${id} blocks itself`);
else if (!target) warnings.push(`#${targetId} does not exist`);
else if (target.blocks.includes(id))
warnings.push(`cycle: #${id} and #${targetId} block each other`);
}
changedFields.push("blocks");
}
if (fields.add_blocked_by?.length) {
for (const targetId of fields.add_blocked_by) {
if (!task.blockedBy.includes(targetId)) task.blockedBy.push(targetId);
const target = this.tasks.get(targetId);
if (target && !target.blocks.includes(id)) { target.blocks.push(id); target.updatedAt = Date.now(); }
if (targetId === id) warnings.push(`#${id} blocks itself`);
else if (!target) warnings.push(`#${targetId} does not exist`);
else if (task.blocks.includes(targetId)) warnings.push(`cycle: #${id} and #${targetId} block each other`);
}
changedFields.push("blockedBy");
}
if (fields.add_blocked_by?.length) {
for (const targetId of fields.add_blocked_by) {
if (!task.blockedBy.includes(targetId)) task.blockedBy.push(targetId);
const target = this.tasks.get(targetId);
if (target && !target.blocks.includes(id)) {
target.blocks.push(id);
target.updatedAt = Date.now();
}
if (targetId === id) warnings.push(`#${id} blocks itself`);
else if (!target) warnings.push(`#${targetId} does not exist`);
else if (task.blocks.includes(targetId))
warnings.push(`cycle: #${id} and #${targetId} block each other`);
}
changedFields.push("blockedBy");
}
task.updatedAt = Date.now();
return { task, changedFields, warnings };
});
}
task.updatedAt = Date.now();
return { task, changedFields, warnings };
});
}
/** Complete a task. Called by accepted proof review or direct subtask completion paths. */
complete(id: string): Task {
return this.withLock(() => {
const task = this.tasks.get(id);
if (!task) throw new Error(`Task #${id} not found`);
if (task.status === "completed") throw new Error(`Task #${id} already completed`);
task.status = "completed";
task.updatedAt = Date.now();
return task;
});
}
/** Complete a task. Called by accepted proof review or direct subtask completion paths. */
complete(id: string): Task {
return this.withLock(() => {
const task = this.tasks.get(id);
if (!task) throw new Error(`Task #${id} not found`);
if (task.status === "completed")
throw new Error(`Task #${id} already completed`);
task.status = "completed";
task.updatedAt = Date.now();
return task;
});
}
delete(id: string): boolean {
return this.withLock(() => {
if (!this.tasks.has(id)) return false;
this.tasks.delete(id);
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter(bid => bid !== id);
t.blockedBy = t.blockedBy.filter(bid => bid !== id);
}
return true;
});
}
delete(id: string): boolean {
return this.withLock(() => {
if (!this.tasks.has(id)) return false;
this.tasks.delete(id);
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter((bid) => bid !== id);
t.blockedBy = t.blockedBy.filter((bid) => bid !== id);
}
return true;
});
}
clearAll(): number {
return this.withLock(() => {
const count = this.tasks.size;
this.tasks.clear();
return count;
});
}
clearAll(): number {
return this.withLock(() => {
const count = this.tasks.size;
this.tasks.clear();
return count;
});
}
deleteFileIfEmpty(): boolean {
if (!this.filePath || this.tasks.size > 0) return false;
try { unlinkSync(this.filePath); } catch { /* ignore */ }
return true;
}
deleteFileIfEmpty(): boolean {
if (!this.filePath || this.tasks.size > 0) return false;
try {
unlinkSync(this.filePath);
} catch {
/* ignore */
}
return true;
}
clearCompleted(): number {
return this.withLock(() => {
let count = 0;
for (const [id, task] of this.tasks) {
if (task.status === "completed") { this.tasks.delete(id); count++; }
}
if (count > 0) {
const validIds = new Set(this.tasks.keys());
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter(bid => validIds.has(bid));
t.blockedBy = t.blockedBy.filter(bid => validIds.has(bid));
}
}
return count;
});
}
clearCompleted(): number {
return this.withLock(() => {
let count = 0;
for (const [id, task] of this.tasks) {
if (task.status === "completed") {
this.tasks.delete(id);
count++;
}
}
if (count > 0) {
const validIds = new Set(this.tasks.keys());
for (const t of this.tasks.values()) {
t.blocks = t.blocks.filter((bid) => validIds.has(bid));
t.blockedBy = t.blockedBy.filter((bid) => validIds.has(bid));
}
}
return count;
});
}
}
src/tasks-config.ts
+10 -8
View File
@@ -4,20 +4,22 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { dirname, join } from "node:path";
export interface TasksConfig {
taskScope?: "memory" | "session" | "project"; // default: "session"
autoCascade?: boolean; // default: false
autoClearCompleted?: "never" | "on_list_complete" | "on_task_complete"; // default: "on_list_complete"
taskScope?: "memory" | "session" | "project"; // default: "session"
autoCascade?: boolean; // default: false
autoClearCompleted?: "never" | "on_list_complete" | "on_task_complete"; // default: "never"
}
const CONFIG_PATH = join(process.cwd(), ".pi", "tasks-config.json");
export function loadTasksConfig(): TasksConfig {
try {
return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
} catch { return {}; }
try {
return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
} catch {
return {};
}
}
export function saveTasksConfig(config: TasksConfig): void {
mkdirSync(dirname(CONFIG_PATH), { recursive: true });
writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
mkdirSync(dirname(CONFIG_PATH), { recursive: true });
writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
}
src/types.ts
+14 -14
View File
@@ -5,22 +5,22 @@
export type TaskStatus = "pending" | "in_progress" | "completed";
export interface Task {
id: string;
subject: string;
description: string;
done_criterion: string; // required: what "done" looks like
parentId?: string; // no parent = top-level goal, requires proof claim to complete
status: TaskStatus;
progress_label?: string;
metadata: Record<string, any>;
blocks: string[];
blockedBy: string[];
createdAt: number;
updatedAt: number;
id: string;
subject: string;
description: string;
done_criterion: string; // required: what "done" looks like
parentId?: string; // no parent = top-level goal, requires proof claim to complete
status: TaskStatus;
progress_label?: string;
metadata: Record<string, any>;
blocks: string[];
blockedBy: string[];
createdAt: number;
updatedAt: number;
}
/** Serialized store format on disk. */
export interface TaskStoreData {
nextId: number;
tasks: Task[];
nextId: number;
tasks: Task[];
}
src/ui/task-widget.ts
+229 -195
View File
@@ -1,11 +1,11 @@
/**
* task-widget.ts — Persistent widget showing task list with status icons and progress.
* task-widget.ts — Persistent widget showing open goals with simple status icons and progress.
*
* Display style matches Claude Code's task list:
* ✔ completed tasks (strikethrough + dim)
* Display style:
* ◼ in_progress tasks
* ◻ pending tasks
* ✳/✽ actively executing task (star spinner with progress_label text)
* Completed tasks stay in storage but are hidden from the collapsed widget.
*/
import { truncateToWidth } from "@mariozechner/pi-tui";
@@ -15,18 +15,23 @@ import type { TaskStore } from "../task-store.js";
// ---- Types ----
export type Theme = {
fg(color: string, text: string): string;
bold(text: string): string;
strikethrough(text: string): string;
fg(color: string, text: string): string;
bold(text: string): string;
strikethrough(text: string): string;
};
export type UICtx = {
setStatus(key: string, text: string | undefined): void;
setWidget(
key: string,
content: undefined | ((tui: any, theme: Theme) => { render(): string[]; invalidate(): void }),
options?: { placement?: "aboveEditor" | "belowEditor" },
): void;
setStatus(key: string, text: string | undefined): void;
setWidget(
key: string,
content:
| undefined
| ((
tui: any,
theme: Theme,
) => { render(): string[]; invalidate(): void }),
options?: { placement?: "aboveEditor" | "belowEditor" },
): void;
};
/** Star spinner frames for animated active task indicator (matches Claude Code). */
@@ -36,225 +41,254 @@ const MAX_VISIBLE_TASKS = 5;
/** Per-task runtime metrics (elapsed time, token usage). */
export interface TaskMetrics {
startedAt: number;
inputTokens: number;
outputTokens: number;
startedAt: number;
inputTokens: number;
outputTokens: number;
}
/** Format milliseconds as a human-readable duration (e.g., "2m 49s", "1h 3m"). */
function formatDuration(ms: number): string {
const totalSec = Math.floor(ms / 1000);
if (totalSec < 60) return `${totalSec}s`;
const min = Math.floor(totalSec / 60);
const sec = totalSec % 60;
if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
const hr = Math.floor(min / 60);
const remMin = min % 60;
return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
const totalSec = Math.floor(ms / 1000);
if (totalSec < 60) return `${totalSec}s`;
const min = Math.floor(totalSec / 60);
const sec = totalSec % 60;
if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
const hr = Math.floor(min / 60);
const remMin = min % 60;
return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
}
/** Format token count with k suffix (e.g., "4.1k", "850"). */
function formatTokens(n: number): string {
if (n < 1000) return String(n);
return (n / 1000).toFixed(1).replace(/\.0$/, "") + "k";
if (n < 1000) return String(n);
return (n / 1000).toFixed(1).replace(/\.0$/, "") + "k";
}
// ---- Widget ----
export class TaskWidget {
private uiCtx: UICtx | undefined;
private widgetFrame = 0;
private widgetInterval: ReturnType<typeof setInterval> | undefined;
/** IDs of tasks currently being actively executed (show spinner). */
private activeTaskIds = new Set<string>();
/** Per-task runtime metrics keyed by task ID. */
private metrics = new Map<string, TaskMetrics>();
/** Cached TUI instance for requestRender() calls. */
private tui: any | undefined;
/** Whether the widget callback is currently registered. */
private widgetRegistered = false;
private uiCtx: UICtx | undefined;
private widgetFrame = 0;
private widgetInterval: ReturnType<typeof setInterval> | undefined;
/** IDs of tasks currently being actively executed (show spinner). */
private activeTaskIds = new Set<string>();
/** Per-task runtime metrics keyed by task ID. */
private metrics = new Map<string, TaskMetrics>();
/** Cached TUI instance for requestRender() calls. */
private tui: any | undefined;
/** Whether the widget callback is currently registered. */
private widgetRegistered = false;
constructor(private store: TaskStore) {}
constructor(private store: TaskStore) {}
setStore(store: TaskStore) {
this.store = store;
}
setStore(store: TaskStore) {
this.store = store;
}
setUICtx(ctx: UICtx) {
this.uiCtx = ctx;
}
setUICtx(ctx: UICtx) {
this.uiCtx = ctx;
}
/** Add or remove a task from the active spinner set. */
setActiveTask(taskId: string | undefined, active = true) {
if (taskId && active) {
this.activeTaskIds.add(taskId);
if (!this.metrics.has(taskId)) {
this.metrics.set(taskId, { startedAt: Date.now(), inputTokens: 0, outputTokens: 0 });
}
this.ensureTimer();
} else if (taskId) {
this.activeTaskIds.delete(taskId);
}
this.update();
}
/** Add or remove a task from the active spinner set. */
setActiveTask(taskId: string | undefined, active = true) {
if (taskId && active) {
this.activeTaskIds.add(taskId);
if (!this.metrics.has(taskId)) {
this.metrics.set(taskId, {
startedAt: Date.now(),
inputTokens: 0,
outputTokens: 0,
});
}
this.ensureTimer();
} else if (taskId) {
this.activeTaskIds.delete(taskId);
}
this.update();
}
/** Record token usage for the currently active task(s). */
addTokenUsage(inputTokens: number, outputTokens: number) {
// Distribute to all currently active tasks
for (const id of this.activeTaskIds) {
const m = this.metrics.get(id);
if (m) {
m.inputTokens += inputTokens;
m.outputTokens += outputTokens;
}
}
}
/** Record token usage for the currently active task(s). */
addTokenUsage(inputTokens: number, outputTokens: number) {
// Distribute to all currently active tasks
for (const id of this.activeTaskIds) {
const m = this.metrics.get(id);
if (m) {
m.inputTokens += inputTokens;
m.outputTokens += outputTokens;
}
}
}
/** Ensure the widget update timer is running. */
ensureTimer() {
if (!this.widgetInterval) {
this.widgetInterval = setInterval(() => this.update(), 80);
}
}
/** Ensure the widget update timer is running. */
ensureTimer() {
if (!this.widgetInterval) {
this.widgetInterval = setInterval(() => this.update(), 80);
}
}
/** Build widget lines from current live state. Called from the render callback. */
private renderWidget(tui: any, theme: Theme): string[] {
const tasks = this.store.list();
const w = tui.terminal.columns;
const truncate = (line: string) => truncateToWidth(line, w);
/** Build widget lines from current live state. Called from the render callback. */
private renderWidget(tui: any, theme: Theme): string[] {
const tasks = this.store.list();
const w = tui.terminal.columns;
const truncate = (line: string) => truncateToWidth(line, w);
if (tasks.length === 0) return [];
if (tasks.length === 0) return [];
const counts = { completed: 0, in_progress: 0, pending: 0 };
for (const t of tasks) counts[getDisplayStatus(t)]++;
const counts = { completed: 0, in_progress: 0, pending: 0 };
for (const t of tasks) counts[getDisplayStatus(t)]++;
const parts: string[] = [];
if (counts.completed > 0) parts.push(`${counts.completed} done`);
if (counts.in_progress > 0) parts.push(`${counts.in_progress} in progress`);
if (counts.pending > 0) parts.push(`${counts.pending} open`);
const statusText = `${tasks.length} tasks (${parts.join(", ")})`;
const visibleTasks = tasks.filter((task) => task.status !== "completed");
if (visibleTasks.length === 0) return [];
const spinnerChar = SPINNER[this.widgetFrame % SPINNER.length];
const lines: string[] = [truncate(theme.fg("accent", "●") + " " + theme.fg("accent", statusText))];
const parts: string[] = [];
if (counts.completed > 0) parts.push(`${counts.completed} done hidden`);
if (counts.in_progress > 0) parts.push(`${counts.in_progress} in progress`);
if (counts.pending > 0) parts.push(`${counts.pending} open`);
const statusText = `${tasks.length} goals (${parts.join(", ")})`;
const visible = tasks.slice(0, MAX_VISIBLE_TASKS);
for (let i = 0; i < visible.length; i++) {
const task = visible[i];
const isActive = this.activeTaskIds.has(task.id) && task.status === "in_progress";
const spinnerChar = SPINNER[this.widgetFrame % SPINNER.length];
const lines: string[] = [
truncate(theme.fg("accent", "●") + " " + theme.fg("accent", statusText)),
];
let icon: string;
if (isActive) {
icon = theme.fg("accent", spinnerChar);
} else if (task.status === "completed") {
icon = theme.fg("success", "✔");
} else if (task.status === "in_progress") {
icon = theme.fg("accent", "◼");
} else {
icon = "◻";
}
const visible = visibleTasks.slice(0, MAX_VISIBLE_TASKS);
for (let i = 0; i < visible.length; i++) {
const task = visible[i];
const isActive =
this.activeTaskIds.has(task.id) && task.status === "in_progress";
let suffix = "";
if (task.status === "pending" && task.blockedBy.length > 0) {
const openBlockers = task.blockedBy.filter(bid => {
const blocker = this.store.get(bid);
return blocker && blocker.status !== "completed";
});
if (openBlockers.length > 0) {
suffix = theme.fg("dim", ` › blocked by ${openBlockers.map(id => "#" + id).join(", ")}`);
}
}
let icon: string;
if (isActive) {
icon = theme.fg("accent", spinnerChar);
} else if (task.status === "in_progress") {
icon = theme.fg("accent", "◼");
} else {
icon = "◻";
}
let text: string;
if (isActive) {
const form = task.progress_label || task.subject;
const m = this.metrics.get(task.id);
let stats = "";
if (m) {
const elapsed = formatDuration(Date.now() - m.startedAt);
const tokenParts: string[] = [];
if (m.inputTokens > 0) tokenParts.push(`↑ ${formatTokens(m.inputTokens)}`);
if (m.outputTokens > 0) tokenParts.push(`↓ ${formatTokens(m.outputTokens)}`);
stats = tokenParts.length > 0
? ` ${theme.fg("dim", `(${elapsed} · ${tokenParts.join(" ")})`)}`
: ` ${theme.fg("dim", `(${elapsed})`)}`;
}
text = ` ${icon} ${theme.fg("dim", "#" + task.id)} ${theme.fg("accent", form + "…")}${stats}`;
} else if (task.status === "completed") {
text = ` ${icon} ${theme.fg("dim", theme.strikethrough("#" + task.id + " " + task.subject))}`;
} else {
text = ` ${icon} ${theme.fg("dim", "#" + task.id)} ${task.subject}`;
}
let suffix = "";
if (task.status === "pending" && task.blockedBy.length > 0) {
const openBlockers = task.blockedBy.filter((bid) => {
const blocker = this.store.get(bid);
return blocker && blocker.status !== "completed";
});
if (openBlockers.length > 0) {
suffix = theme.fg(
"dim",
` › blocked by ${openBlockers.map((id) => "#" + id).join(", ")}`,
);
}
}
lines.push(truncate(text + suffix));
}
let text: string;
if (isActive) {
const form = task.progress_label || task.subject;
const m = this.metrics.get(task.id);
let stats = "";
if (m) {
const elapsed = formatDuration(Date.now() - m.startedAt);
const tokenParts: string[] = [];
if (m.inputTokens > 0)
tokenParts.push(`↑ ${formatTokens(m.inputTokens)}`);
if (m.outputTokens > 0)
tokenParts.push(`↓ ${formatTokens(m.outputTokens)}`);
stats =
tokenParts.length > 0
? ` ${theme.fg("dim", `(${elapsed}, ${tokenParts.join(" ")})`)}`
: ` ${theme.fg("dim", `(${elapsed})`)}`;
}
text = ` ${icon} ${theme.fg("dim", "#" + task.id)} ${theme.fg("accent", form + "…")}${stats}`;
} else {
text = ` ${icon} ${theme.fg("dim", "#" + task.id)} ${task.subject}`;
}
if (tasks.length > MAX_VISIBLE_TASKS) {
lines.push(truncate(theme.fg("dim", ` … and ${tasks.length - MAX_VISIBLE_TASKS} more`)));
}
lines.push(truncate(text + suffix));
}
return lines;
}
if (visibleTasks.length > MAX_VISIBLE_TASKS) {
lines.push(
truncate(
theme.fg(
"dim",
` … and ${visibleTasks.length - MAX_VISIBLE_TASKS} more open`,
),
),
);
}
/** Force an immediate widget update. */
update() {
if (!this.uiCtx) return;
const tasks = this.store.list();
return lines;
}
// Transition: visible → hidden
if (tasks.length === 0) {
if (this.widgetRegistered) {
this.uiCtx.setWidget("tasks", undefined);
this.widgetRegistered = false;
}
if (this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
return;
}
/** Force an immediate widget update. */
update() {
if (!this.uiCtx) return;
const tasks = this.store.list();
const visibleTasks = tasks.filter((task) => task.status !== "completed");
// Prune stale active IDs (deleted or no longer in_progress)
for (const id of this.activeTaskIds) {
const t = this.store.get(id);
if (!t || t.status !== "in_progress") {
this.activeTaskIds.delete(id);
this.metrics.delete(id);
}
}
// Transition: visible → hidden
if (visibleTasks.length === 0) {
if (this.widgetRegistered) {
this.uiCtx.setWidget("tasks", undefined);
this.widgetRegistered = false;
}
if (this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
return;
}
// Check if any task needs animation
const hasActiveSpinner = tasks.some(t => this.activeTaskIds.has(t.id) && t.status === "in_progress");
if (hasActiveSpinner) {
this.ensureTimer();
} else if (!hasActiveSpinner && this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
// Prune stale active IDs (deleted or no longer in_progress)
for (const id of this.activeTaskIds) {
const t = this.store.get(id);
if (!t || t.status !== "in_progress") {
this.activeTaskIds.delete(id);
this.metrics.delete(id);
}
}
this.widgetFrame++;
// Check if any task needs animation
const hasActiveSpinner = tasks.some(
(t) => this.activeTaskIds.has(t.id) && t.status === "in_progress",
);
if (hasActiveSpinner) {
this.ensureTimer();
} else if (!hasActiveSpinner && this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
// Transition: hidden → visible — register widget callback once
if (!this.widgetRegistered) {
this.uiCtx.setWidget("tasks", (tui, theme) => {
this.tui = tui;
return { render: () => this.renderWidget(tui, theme), invalidate: () => {} };
}, { placement: "aboveEditor" });
this.widgetRegistered = true;
} else if (this.tui) {
// Widget already registered — just request a re-render
this.tui.requestRender();
}
}
this.widgetFrame++;
dispose() {
if (this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
if (this.uiCtx) {
this.uiCtx.setWidget("tasks", undefined);
}
this.widgetRegistered = false;
this.tui = undefined;
}
// Transition: hidden → visible — register widget callback once
if (!this.widgetRegistered) {
this.uiCtx.setWidget(
"tasks",
(tui, theme) => {
this.tui = tui;
return {
render: () => this.renderWidget(tui, theme),
invalidate: () => {},
};
},
{ placement: "aboveEditor" },
);
this.widgetRegistered = true;
} else if (this.tui) {
// Widget already registered — just request a re-render
this.tui.requestRender();
}
}
dispose() {
if (this.widgetInterval) {
clearInterval(this.widgetInterval);
this.widgetInterval = undefined;
}
if (this.uiCtx) {
this.uiCtx.setWidget("tasks", undefined);
}
this.widgetRegistered = false;
this.tui = undefined;
}
}
test/auto-clear.test.ts
+271 -244
View File
@@ -4,318 +4,345 @@ import { AutoClearManager } from "../src/auto-clear.js";
import { TaskStore } from "../src/task-store.js";
describe("auto-clear: on_task_complete mode", () => {
let store: TaskStore;
let manager: AutoClearManager;
let store: TaskStore;
let manager: AutoClearManager;
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(() => store, () => "on_task_complete");
});
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(
() => store,
() => "on_task_complete",
);
});
it("does not clear completed task before REMINDER_INTERVAL turns", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("does not clear completed task before REMINDER_INTERVAL turns", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Turns 2, 3, 4 — not enough
for (let turn = 2; turn <= 4; turn++) {
manager.onTurnStart(turn);
}
expect(store.get("1")).toBeDefined();
expect(store.get("1")!.status).toBe("completed");
});
// Turns 2, 3, 4 — not enough
for (let turn = 2; turn <= 4; turn++) {
manager.onTurnStart(turn);
}
expect(store.get("1")).toBeDefined();
expect(store.get("1")!.status).toBe("completed");
});
it("clears completed task after REMINDER_INTERVAL turns", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("clears completed task after REMINDER_INTERVAL turns", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Turn 5 = turn 1 + 4 (REMINDER_INTERVAL)
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.list()).toHaveLength(0);
});
// Turn 5 = turn 1 + 4 (REMINDER_INTERVAL)
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.list()).toHaveLength(0);
});
it("clears each task independently based on its own completion turn", () => {
store.create("Task A", "Desc", "done");
store.create("Task B", "Desc", "done");
it("clears each task independently based on its own completion turn", () => {
store.create("Task A", "Desc", "done");
store.create("Task B", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
store.complete("1");
manager.trackCompletion("1", 1);
store.complete("2");
manager.trackCompletion("2", 3);
store.complete("2");
manager.trackCompletion("2", 3);
// Turn 5: Task A expires (1+4), Task B still lingers (3+4=7)
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.get("2")).toBeDefined();
// Turn 5: Task A expires (1+4), Task B still lingers (3+4=7)
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.get("2")).toBeDefined();
// Turn 7: Task B expires
manager.onTurnStart(7);
expect(store.get("2")).toBeUndefined();
});
// Turn 7: Task B expires
manager.onTurnStart(7);
expect(store.get("2")).toBeUndefined();
});
it("does not clear pending or in_progress tasks", () => {
store.create("Pending", "Desc", "done");
store.create("In Progress", "Desc", "done");
store.create("Completed", "Desc", "done");
store.update("2", { status: "in_progress" });
store.complete("3");
manager.trackCompletion("3", 1);
it("does not clear pending or in_progress tasks", () => {
store.create("Pending", "Desc", "done");
store.create("In Progress", "Desc", "done");
store.create("Completed", "Desc", "done");
store.update("2", { status: "in_progress" });
store.complete("3");
manager.trackCompletion("3", 1);
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined(); // pending — untouched
expect(store.get("2")).toBeDefined(); // in_progress — untouched
expect(store.get("3")).toBeUndefined(); // completed — cleared
});
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined(); // pending — untouched
expect(store.get("2")).toBeDefined(); // in_progress — untouched
expect(store.get("3")).toBeUndefined(); // completed — cleared
});
it("cleans up dependency edges when auto-clearing", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.complete("1");
manager.trackCompletion("1", 1);
it("cleans up dependency edges when auto-clearing", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.complete("1");
manager.trackCompletion("1", 1);
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.get("2")!.blockedBy).toEqual([]);
});
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined();
expect(store.get("2")!.blockedBy).toEqual([]);
});
it("returns true when tasks are cleared", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("returns true when tasks are cleared", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
expect(manager.onTurnStart(4)).toBe(false);
expect(manager.onTurnStart(5)).toBe(true);
});
expect(manager.onTurnStart(4)).toBe(false);
expect(manager.onTurnStart(5)).toBe(true);
});
});
describe("auto-clear: on_list_complete mode", () => {
let store: TaskStore;
let manager: AutoClearManager;
let store: TaskStore;
let manager: AutoClearManager;
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(() => store, () => "on_list_complete");
});
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(
() => store,
() => "on_list_complete",
);
});
it("does not clear when some tasks are still pending", () => {
store.create("Done", "Desc", "done");
store.create("Pending", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("does not clear when some tasks are still pending", () => {
store.create("Done", "Desc", "done");
store.create("Pending", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
for (let turn = 2; turn <= 10; turn++) {
manager.onTurnStart(turn);
}
expect(store.get("1")).toBeDefined();
expect(store.list()).toHaveLength(2);
});
for (let turn = 2; turn <= 10; turn++) {
manager.onTurnStart(turn);
}
expect(store.get("1")).toBeDefined();
expect(store.list()).toHaveLength(2);
});
it("does not clear immediately when all tasks complete", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
it("does not clear immediately when all tasks complete", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
// Turns 2-4: not enough
for (let turn = 2; turn <= 4; turn++) {
manager.onTurnStart(turn);
}
expect(store.list()).toHaveLength(2);
});
// Turns 2-4: not enough
for (let turn = 2; turn <= 4; turn++) {
manager.onTurnStart(turn);
}
expect(store.list()).toHaveLength(2);
});
it("clears all completed tasks after REMINDER_INTERVAL turns when all are completed", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
it("clears all completed tasks after REMINDER_INTERVAL turns when all are completed", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
manager.onTurnStart(5);
expect(store.list()).toHaveLength(0);
});
manager.onTurnStart(5);
expect(store.list()).toHaveLength(0);
});
it("resets countdown when a new task is created before REMINDER_INTERVAL", () => {
store.create("A", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("resets countdown when a new task is created before REMINDER_INTERVAL", () => {
store.create("A", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Turn 3: new task created — reset countdown
manager.onTurnStart(3);
manager.resetBatchCountdown();
store.create("B", "Desc", "done");
// Turn 3: new task created — reset countdown
manager.onTurnStart(3);
manager.resetBatchCountdown();
store.create("B", "Desc", "done");
// Turn 5 would have cleared, but countdown was reset at turn 3
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined(); // still around — list isn't all completed
});
// Turn 5 would have cleared, but countdown was reset at turn 3
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined(); // still around — list isn't all completed
});
it("resets countdown when a task goes back to in_progress", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
it("resets countdown when a task goes back to in_progress", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("2", 1);
// Turn 3: task 2 goes back to in_progress
manager.onTurnStart(3);
store.update("2", { status: "in_progress" });
manager.resetBatchCountdown();
// Turn 3: task 2 goes back to in_progress
manager.onTurnStart(3);
store.update("2", { status: "in_progress" });
manager.resetBatchCountdown();
// Turn 5: would have cleared, but countdown was reset
manager.onTurnStart(5);
expect(store.list()).toHaveLength(2); // both still here
});
// Turn 5: would have cleared, but countdown was reset
manager.onTurnStart(5);
expect(store.list()).toHaveLength(2); // both still here
});
it("returns true when tasks are cleared", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("returns true when tasks are cleared", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
expect(manager.onTurnStart(4)).toBe(false);
expect(manager.onTurnStart(5)).toBe(true);
});
expect(manager.onTurnStart(4)).toBe(false);
expect(manager.onTurnStart(5)).toBe(true);
});
});
describe("auto-clear: never mode", () => {
let store: TaskStore;
let manager: AutoClearManager;
let store: TaskStore;
let manager: AutoClearManager;
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(() => store, () => "never");
});
beforeEach(() => {
store = new TaskStore();
manager = new AutoClearManager(
() => store,
() => "never",
);
});
it("never clears completed tasks regardless of turns", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("1", 1);
manager.trackCompletion("2", 1);
it("never clears completed tasks regardless of turns", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.complete("1");
store.complete("2");
manager.trackCompletion("1", 1);
manager.trackCompletion("2", 1);
for (let turn = 2; turn <= 20; turn++) {
manager.onTurnStart(turn);
}
expect(store.list()).toHaveLength(2);
});
for (let turn = 2; turn <= 20; turn++) {
manager.onTurnStart(turn);
}
expect(store.list()).toHaveLength(2);
});
it("trackCompletion is a no-op", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
it("trackCompletion is a no-op", () => {
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
manager.onTurnStart(100);
expect(store.get("1")).toBeDefined();
});
manager.onTurnStart(100);
expect(store.get("1")).toBeDefined();
});
});
describe("auto-clear: dynamic mode switching", () => {
it("respects mode changes via getMode callback", () => {
const store = new TaskStore();
let mode: AutoClearMode = "never";
const manager = new AutoClearManager(() => store, () => mode);
it("respects mode changes via getMode callback", () => {
const store = new TaskStore();
let mode: AutoClearMode = "never";
const manager = new AutoClearManager(
() => store,
() => mode,
);
store.create("Task", "Desc", "done");
store.complete("1");
store.create("Task", "Desc", "done");
store.complete("1");
// Track in never mode — no-op
manager.trackCompletion("1", 1);
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
// Track in never mode — no-op
manager.trackCompletion("1", 1);
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
// Switch to on_task_complete and re-track
mode = "on_task_complete";
manager.trackCompletion("1", 5);
manager.onTurnStart(9);
expect(store.get("1")).toBeUndefined();
});
// Switch to on_task_complete and re-track
mode = "on_task_complete";
manager.trackCompletion("1", 5);
manager.onTurnStart(9);
expect(store.get("1")).toBeUndefined();
});
});
describe("auto-clear: store getter (session switch)", () => {
it("operates on the current store after swap", () => {
let store = new TaskStore();
const manager = new AutoClearManager(() => store, () => "on_task_complete");
it("operates on the current store after swap", () => {
let store = new TaskStore();
const manager = new AutoClearManager(
() => store,
() => "on_task_complete",
);
store.create("Old task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
store.create("Old task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Simulate session switch — swap store
store = new TaskStore();
store.create("New task", "Desc", "done");
manager.reset();
// Simulate session switch — swap store
store = new TaskStore();
store.create("New task", "Desc", "done");
manager.reset();
// Old task tracking was reset, new store has no completed tasks
manager.onTurnStart(5);
expect(store.list()).toHaveLength(1);
expect(store.get("1")!.subject).toBe("New task");
});
// Old task tracking was reset, new store has no completed tasks
manager.onTurnStart(5);
expect(store.list()).toHaveLength(1);
expect(store.get("1")!.subject).toBe("New task");
});
it("clears from new store, not old store", () => {
let store = new TaskStore();
const manager = new AutoClearManager(() => store, () => "on_task_complete");
it("clears from new store, not old store", () => {
let store = new TaskStore();
const manager = new AutoClearManager(
() => store,
() => "on_task_complete",
);
// Swap to new store with a completed task
store = new TaskStore();
store.create("Task in new store", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Swap to new store with a completed task
store = new TaskStore();
store.create("Task in new store", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined(); // cleared from new store
});
manager.onTurnStart(5);
expect(store.get("1")).toBeUndefined(); // cleared from new store
});
});
describe("auto-clear: reset (new session)", () => {
it("reset clears per-task tracking so old completions don't fire", () => {
const store = new TaskStore();
const manager = new AutoClearManager(() => store, () => "on_task_complete");
it("reset clears per-task tracking so old completions don't fire", () => {
const store = new TaskStore();
const manager = new AutoClearManager(
() => store,
() => "on_task_complete",
);
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Simulate /new — reset before the delay expires
manager.reset();
// Simulate /new — reset before the delay expires
manager.reset();
// Old completion should NOT trigger after reset
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
});
// Old completion should NOT trigger after reset
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
});
it("reset clears batch countdown so old all-completed state doesn't fire", () => {
const store = new TaskStore();
const manager = new AutoClearManager(() => store, () => "on_list_complete");
it("reset clears batch countdown so old all-completed state doesn't fire", () => {
const store = new TaskStore();
const manager = new AutoClearManager(
() => store,
() => "on_list_complete",
);
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
// Simulate /new — reset before the delay expires
manager.reset();
// Simulate /new — reset before the delay expires
manager.reset();
// Old batch countdown should NOT trigger after reset
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
});
// Old batch countdown should NOT trigger after reset
manager.onTurnStart(5);
expect(store.get("1")).toBeDefined();
});
it("tracking works normally after reset", () => {
const store = new TaskStore();
const manager = new AutoClearManager(() => store, () => "on_task_complete");
it("tracking works normally after reset", () => {
const store = new TaskStore();
const manager = new AutoClearManager(
() => store,
() => "on_task_complete",
);
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
manager.reset();
store.create("Task", "Desc", "done");
store.complete("1");
manager.trackCompletion("1", 1);
manager.reset();
// Re-track after reset with new turn baseline
manager.trackCompletion("1", 10);
manager.onTurnStart(14);
expect(store.get("1")).toBeUndefined();
});
// Re-track after reset with new turn baseline
manager.trackCompletion("1", 10);
manager.onTurnStart(14);
expect(store.get("1")).toBeUndefined();
});
});
test/lgtm-command.test.ts
+128 -86
View File
@@ -2,123 +2,165 @@ import { describe, expect, it, vi } from "vitest";
import proofTasksExtension, { parseLgtmArgs } from "../src/index.js";
type RegisteredTool = {
name: string;
execute: (...args: any[]) => Promise<any>;
name: string;
execute: (...args: any[]) => Promise<any>;
};
type RegisteredCommand = {
handler: (args: string, ctx: any) => Promise<void>;
getArgumentCompletions?: (args: string) => Promise<string[]>;
handler: (args: string, ctx: any) => Promise<void>;
getArgumentCompletions?: (args: string) => Promise<string[]>;
};
function makeHarness() {
const tools = new Map<string, RegisteredTool>();
const commands = new Map<string, RegisteredCommand>();
const sentMessages: any[] = [];
const tools = new Map<string, RegisteredTool>();
const commands = new Map<string, RegisteredCommand>();
const sentMessages: any[] = [];
const pi = {
on: vi.fn(),
registerTool: vi.fn((tool: RegisteredTool) => tools.set(tool.name, tool)),
registerCommand: vi.fn((name: string, command: RegisteredCommand) => commands.set(name, command)),
sendMessage: vi.fn((message: any) => sentMessages.push(message)),
};
const pi = {
on: vi.fn(),
registerTool: vi.fn((tool: RegisteredTool) => tools.set(tool.name, tool)),
registerCommand: vi.fn((name: string, command: RegisteredCommand) =>
commands.set(name, command),
),
sendMessage: vi.fn((message: any) => sentMessages.push(message)),
};
proofTasksExtension(pi as any);
proofTasksExtension(pi as any);
async function execTool(name: string, params: Record<string, unknown>) {
const tool = tools.get(name);
if (!tool) throw new Error(`Tool ${name} not registered`);
return tool.execute("tool-call", params, undefined, undefined, {});
}
async function execTool(name: string, params: Record<string, unknown>) {
const tool = tools.get(name);
if (!tool) throw new Error(`Tool ${name} not registered`);
return tool.execute("tool-call", params, undefined, undefined, {});
}
function makeUi(overrides: {
select?: Array<string | undefined>;
confirm?: Array<boolean>;
} = {}) {
const selectQueue = [...(overrides.select ?? [])];
const confirmQueue = [...(overrides.confirm ?? [])];
return {
notify: vi.fn(),
select: vi.fn(async () => selectQueue.shift()),
confirm: vi.fn(async () => confirmQueue.shift() ?? false),
};
}
function makeUi(
overrides: {
select?: Array<string | undefined>;
confirm?: Array<boolean>;
} = {},
) {
const selectQueue = [...(overrides.select ?? [])];
const confirmQueue = [...(overrides.confirm ?? [])];
return {
notify: vi.fn(),
select: vi.fn(async () => selectQueue.shift()),
confirm: vi.fn(async () => confirmQueue.shift() ?? false),
};
}
return { tools, commands, sentMessages, execTool, makeUi };
return { tools, commands, sentMessages, execTool, makeUi };
}
describe("parseLgtmArgs", () => {
it("parses menu and view forms", () => {
expect(parseLgtmArgs("")).toEqual({ kind: "menu" });
expect(parseLgtmArgs("*")).toEqual({ kind: "view_all" });
expect(parseLgtmArgs("1 #2")).toEqual({ kind: "view", ids: ["1", "2"] });
});
it("parses menu and view forms", () => {
expect(parseLgtmArgs("")).toEqual({ kind: "menu" });
expect(parseLgtmArgs("*")).toEqual({ kind: "view_all" });
expect(parseLgtmArgs("1 #2")).toEqual({ kind: "view", ids: ["1", "2"] });
});
it("rejects task-management forms", () => {
expect(parseLgtmArgs("clear")).toEqual({ kind: "error", message: "Task management lives in /tasks now. /lgtm is viewer-only." });
expect(parseLgtmArgs("clear *")).toEqual({ kind: "error", message: "Task management lives in /tasks now. /lgtm is viewer-only." });
expect(parseLgtmArgs("clear #7")).toEqual({ kind: "error", message: "Task management lives in /tasks now. /lgtm is viewer-only." });
expect(parseLgtmArgs("delete #7")).toEqual({ kind: "error", message: "Task management lives in /tasks now. /lgtm is viewer-only." });
});
it("rejects task-management forms", () => {
expect(parseLgtmArgs("clear")).toEqual({
kind: "error",
message: "Task management lives in /tasks now. /lgtm is viewer-only.",
});
expect(parseLgtmArgs("clear *")).toEqual({
kind: "error",
message: "Task management lives in /tasks now. /lgtm is viewer-only.",
});
expect(parseLgtmArgs("clear #7")).toEqual({
kind: "error",
message: "Task management lives in /tasks now. /lgtm is viewer-only.",
});
expect(parseLgtmArgs("delete #7")).toEqual({
kind: "error",
message: "Task management lives in /tasks now. /lgtm is viewer-only.",
});
});
});
describe("/lgtm command", () => {
it("shows all open proof logs from the picker", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", { subject: "Task A", description: "Desc", done_criterion: "done" });
await harness.execTool("TaskCreate", { subject: "Task B", description: "Desc", done_criterion: "done" });
it("shows all open proof logs from the picker", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Task A",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Task B",
description: "Desc",
done_criterion: "done",
});
const ui = harness.makeUi({ select: ["View all open proof logs"] });
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
const ui = harness.makeUi({ select: ["View all open proof logs"] });
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
await command.handler("", { ui });
await command.handler("", { ui });
expect(harness.sentMessages).toHaveLength(2);
expect(harness.sentMessages[0].customType).toBe("proof-log");
expect(harness.sentMessages[0].content).toContain("Task #1");
expect(harness.sentMessages[1].content).toContain("Task #2");
});
expect(harness.sentMessages).toHaveLength(2);
expect(harness.sentMessages[0].customType).toBe("proof-log");
expect(harness.sentMessages[0].content).toContain("Task #1");
expect(harness.sentMessages[1].content).toContain("Task #2");
});
it("shows one proof log from the picker", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", { subject: "Task A", description: "Desc", done_criterion: "done" });
it("shows one proof log from the picker", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Task A",
description: "Desc",
done_criterion: "done",
});
const ui = harness.makeUi({ select: ["[PENDING] #1 Task A"] });
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
const ui = harness.makeUi({ select: ["[PENDING] #1 Task A"] });
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
await command.handler("", { ui });
await command.handler("", { ui });
expect(harness.sentMessages).toHaveLength(1);
expect(harness.sentMessages[0].content).toContain("Task #1");
});
expect(harness.sentMessages).toHaveLength(1);
expect(harness.sentMessages[0].content).toContain("Task #1");
});
it("rejects /lgtm clear and points task management back to /tasks", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", { subject: "Task A", description: "Desc", done_criterion: "done" });
it("rejects /lgtm clear and points task management back to /tasks", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Task A",
description: "Desc",
done_criterion: "done",
});
const ui = harness.makeUi();
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
const ui = harness.makeUi();
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
await command.handler("clear 1", { ui });
await command.handler("clear 1", { ui });
expect(harness.sentMessages).toHaveLength(0);
expect(ui.notify).toHaveBeenCalledWith("Task management lives in /tasks now. /lgtm is viewer-only.", "error");
});
expect(harness.sentMessages).toHaveLength(0);
expect(ui.notify).toHaveBeenCalledWith(
"Task management lives in /tasks now. /lgtm is viewer-only.",
"error",
);
});
it("rejects /lgtm delete and points task management back to /tasks", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", { subject: "Task A", description: "Desc", done_criterion: "done" });
it("rejects /lgtm delete and points task management back to /tasks", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Task A",
description: "Desc",
done_criterion: "done",
});
const ui = harness.makeUi();
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
const ui = harness.makeUi();
const command = harness.commands.get("lgtm");
if (!command) throw new Error("/lgtm not registered");
await command.handler("delete 1", { ui });
await command.handler("delete 1", { ui });
expect(harness.sentMessages).toHaveLength(0);
expect(ui.notify).toHaveBeenCalledWith("Task management lives in /tasks now. /lgtm is viewer-only.", "error");
});
expect(harness.sentMessages).toHaveLength(0);
expect(ui.notify).toHaveBeenCalledWith(
"Task management lives in /tasks now. /lgtm is viewer-only.",
"error",
);
});
});
test/review-badges.test.ts
+124 -129
View File
@@ -1,150 +1,145 @@
import { describe, expect, it } from "vitest";
import { getCompletionMode, getDisplayStatus, getGateStatus, getReviewBadges, getReviewState } from "../src/review-badges.js";
import {
getCompletionMode,
getDisplayStatus,
getGateStatus,
getReviewState,
} from "../src/review-badges.js";
import type { Task } from "../src/types.js";
function makeTask(overrides: Partial<Task> = {}): Task {
return {
id: "1",
subject: "Test",
description: "Desc",
done_criterion: "done",
status: "pending",
progress_label: undefined,
metadata: {},
blocks: [],
blockedBy: [],
createdAt: 0,
updatedAt: 0,
...overrides,
};
return {
id: "1",
subject: "Test",
description: "Desc",
done_criterion: "done",
status: "pending",
progress_label: undefined,
metadata: {},
blocks: [],
blockedBy: [],
createdAt: 0,
updatedAt: 0,
...overrides,
};
}
describe("getReviewBadges", () => {
it("renders all dots when no artifacts exist", () => {
expect(getReviewBadges(makeTask())).toBe("[···]");
});
it("fills evidence/review/completed slots independently", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "npm test",
robot_reviews: [{
iteration: 1,
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed one unchecked edge case"],
concerns: ["Evidence does not cover prod traffic."],
suggestions: ["Inspect one prod traffic sample."],
blind_spots: "Did not inspect prod traffic",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["Prod traffic sample"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "manual",
}],
},
});
expect(getReviewBadges(task)).toBe("[🛠🤖·]");
});
it("fills the completed badge once the task is completed", () => {
const task = makeTask({
status: "completed",
metadata: { lgtm_evidence: "ok" },
});
expect(getReviewBadges(task)).toBe("[🛠·✓]");
});
});
describe("review state helpers", () => {
it("reports completion mode as proof for top-level tasks", () => {
expect(getCompletionMode(makeTask())).toBe("proof");
});
it("reports completion mode as proof for top-level tasks", () => {
expect(getCompletionMode(makeTask())).toBe("proof");
});
it("reports completion mode as direct for subtasks", () => {
expect(getCompletionMode(makeTask({ parentId: "1" }))).toBe("direct");
});
it("reports completion mode as direct for subtasks", () => {
expect(getCompletionMode(makeTask({ parentId: "1" }))).toBe("direct");
});
it("reports superseded when only history remains", () => {
expect(getReviewState(makeTask({ metadata: { lgtm_history: [{ iteration: 1 }] } }))).toBe("superseded");
});
it("reports superseded when only history remains", () => {
expect(
getReviewState(
makeTask({ metadata: { lgtm_history: [{ iteration: 1 }] } }),
),
).toBe("superseded");
});
});
describe("getGateStatus", () => {
it("reports top-level proof requirement before evidence", () => {
expect(getGateStatus(makeTask())).toBe("top-level task requires TaskClaimDone evidence before completion");
});
it("reports top-level proof requirement before evidence", () => {
expect(getGateStatus(makeTask())).toBe(
"top-level task requires TaskClaimDone evidence before completion",
);
});
it("reports non-blocking reviewer failure", () => {
expect(getGateStatus(makeTask({
metadata: {
lgtm_evidence: "ok",
robot_review_last_error: "Unexpected token 'a'",
},
}))).toContain("review unavailable; autonomy continues");
});
it("reports non-blocking reviewer failure", () => {
expect(
getGateStatus(
makeTask({
metadata: {
lgtm_evidence: "ok",
robot_review_last_error: "Unexpected token 'a'",
},
}),
),
).toContain("review unavailable; autonomy continues");
});
it("reports rejected robot review when latest review does not accept", () => {
expect(getGateStatus(makeTask({
metadata: {
lgtm_evidence: "ok",
robot_reviews: [{
iteration: 1,
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing output"],
concerns: ["The current evidence is summary-only."],
suggestions: ["Paste the literal output."],
blind_spots: "none",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["literal output"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "manual",
}],
},
}))).toBe("latest proof review rejected the evidence; strengthen the proof and try again");
});
it("reports rejected robot review when latest review does not accept", () => {
expect(
getGateStatus(
makeTask({
metadata: {
lgtm_evidence: "ok",
robot_reviews: [
{
iteration: 1,
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing output"],
concerns: ["The current evidence is summary-only."],
suggestions: ["Paste the literal output."],
blind_spots: "none",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["literal output"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "manual",
},
],
},
}),
),
).toBe(
"latest proof review rejected the evidence; strengthen the proof and try again",
);
});
it("keeps rejection higher priority than a later reviewer warning", () => {
expect(getGateStatus(makeTask({
metadata: {
lgtm_evidence: "ok",
robot_review_last_error: "timeout",
robot_reviews: [{
iteration: 1,
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing output"],
concerns: ["The current evidence is summary-only."],
suggestions: ["Paste the literal output."],
blind_spots: "none",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["literal output"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "manual",
}],
},
}))).toBe("latest proof review rejected the evidence; strengthen the proof and try again");
});
it("keeps rejection higher priority than a later reviewer warning", () => {
expect(
getGateStatus(
makeTask({
metadata: {
lgtm_evidence: "ok",
robot_review_last_error: "timeout",
robot_reviews: [
{
iteration: 1,
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing output"],
concerns: ["The current evidence is summary-only."],
suggestions: ["Paste the literal output."],
blind_spots: "none",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["literal output"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "manual",
},
],
},
}),
),
).toBe(
"latest proof review rejected the evidence; strengthen the proof and try again",
);
});
});
describe("getDisplayStatus", () => {
it("returns pending for fresh tasks", () => {
expect(getDisplayStatus(makeTask())).toBe("pending");
});
it("returns pending for fresh tasks", () => {
expect(getDisplayStatus(makeTask())).toBe("pending");
});
it("returns in_progress for active tasks not yet escalated", () => {
expect(getDisplayStatus(makeTask({ status: "in_progress" }))).toBe("in_progress");
});
it("returns in_progress for active tasks not yet escalated", () => {
expect(getDisplayStatus(makeTask({ status: "in_progress" }))).toBe(
"in_progress",
);
});
it("returns completed for completed tasks", () => {
expect(getDisplayStatus(makeTask({ status: "completed" }))).toBe("completed");
});
it("returns completed for completed tasks", () => {
expect(getDisplayStatus(makeTask({ status: "completed" }))).toBe(
"completed",
);
});
});
test/robot-review-runner.test.ts
+102 -65
View File
@@ -1,78 +1,115 @@
import { describe, expect, it } from "vitest";
import {
DEFAULT_ROBOT_REVIEW_TIMEOUT_MS,
extractFinalAssistantTextFromPiJsonl,
extractRobotReviewJson,
getCurrentModelRef,
getPiInvocation,
getRobotReviewTimeoutMs,
runRobotReviewCommand,
DEFAULT_ROBOT_REVIEW_TIMEOUT_MS,
extractFinalAssistantTextFromPiJsonl,
extractRobotReviewJson,
getCurrentModelRef,
getPiInvocation,
getRobotReviewTimeoutMs,
runRobotReviewCommand,
} from "../src/index.js";
describe("robot review runner helpers", () => {
it("uses plain pi by default and allows override", () => {
expect(getPiInvocation(["--mode", "json"], {} as NodeJS.ProcessEnv)).toEqual({
command: "pi",
args: ["--mode", "json"],
});
expect(getPiInvocation(["-p"], { PI_PROOF_TASKS_PI_BIN: "/custom/pi" } as NodeJS.ProcessEnv)).toEqual({
command: "/custom/pi",
args: ["-p"],
});
});
it("uses plain pi by default and allows override", () => {
expect(
getPiInvocation(["--mode", "json"], {} as NodeJS.ProcessEnv),
).toEqual({
command: "pi",
args: ["--mode", "json"],
});
expect(
getPiInvocation(["-p"], {
PI_PROOF_TASKS_PI_BIN: "/custom/pi",
} as NodeJS.ProcessEnv),
).toEqual({
command: "/custom/pi",
args: ["-p"],
});
});
it("parses the final assistant text from pi jsonl", () => {
const output = [
"{\"type\":\"message_update\"}",
"{\"type\":\"message_end\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"ROBOT_REVIEW_JSON_START {\\\"accepted\\\":true} ROBOT_REVIEW_JSON_END\"}]}}",
].join("\n");
expect(extractFinalAssistantTextFromPiJsonl(output)).toContain("ROBOT_REVIEW_JSON_START");
});
it("parses the final assistant text from pi jsonl", () => {
const output = [
'{"type":"message_update"}',
'{"type":"message_end","message":{"role":"assistant","content":[{"type":"text","text":"ROBOT_REVIEW_JSON_START {\\"accepted\\":true} ROBOT_REVIEW_JSON_END"}]}}',
].join("\n");
expect(extractFinalAssistantTextFromPiJsonl(output)).toContain(
"ROBOT_REVIEW_JSON_START",
);
});
it("parses noisy JSON wrapped in review markers", () => {
const output = [
"ROBOT_REVIEW_JSON_START",
"and here is the JSON you asked for:",
"```json",
'{"accepted":true,"observations":["ok"]}',
"```",
"ROBOT_REVIEW_JSON_END",
].join("\n");
expect(extractRobotReviewJson(output)).toEqual({ accepted: true, observations: ["ok"] });
});
it("parses noisy JSON wrapped in review markers", () => {
const output = [
"ROBOT_REVIEW_JSON_START",
"and here is the JSON you asked for:",
"```json",
'{"accepted":true,"observations":["ok"]}',
"```",
"ROBOT_REVIEW_JSON_END",
].join("\n");
expect(extractRobotReviewJson(output)).toEqual({
accepted: true,
observations: ["ok"],
});
});
it("includes raw output context on parse failure", () => {
expect(() => extractRobotReviewJson("ROBOT_REVIEW_JSON_START and nope ROBOT_REVIEW_JSON_END")).toThrow(/Raw output:/);
});
it("includes raw output context on parse failure", () => {
expect(() =>
extractRobotReviewJson(
"ROBOT_REVIEW_JSON_START and nope ROBOT_REVIEW_JSON_END",
),
).toThrow(/Raw output:/);
});
it("uses configured timeout or falls back to default", () => {
expect(getRobotReviewTimeoutMs({ PI_PROOF_TASKS_ROBOT_REVIEW_TIMEOUT_MS: "2500" } as NodeJS.ProcessEnv)).toBe(2500);
expect(getRobotReviewTimeoutMs({ PI_PROOF_TASKS_ROBOT_REVIEW_TIMEOUT_MS: "bad" } as NodeJS.ProcessEnv)).toBe(DEFAULT_ROBOT_REVIEW_TIMEOUT_MS);
});
it("uses configured timeout or falls back to default", () => {
expect(
getRobotReviewTimeoutMs({
PI_PROOF_TASKS_ROBOT_REVIEW_TIMEOUT_MS: "2500",
} as NodeJS.ProcessEnv),
).toBe(2500);
expect(
getRobotReviewTimeoutMs({
PI_PROOF_TASKS_ROBOT_REVIEW_TIMEOUT_MS: "bad",
} as NodeJS.ProcessEnv),
).toBe(DEFAULT_ROBOT_REVIEW_TIMEOUT_MS);
});
it("formats the current model as the reviewer model ref", () => {
expect(getCurrentModelRef({ provider: "openai", id: "gpt-5" })).toBe("openai/gpt-5");
expect(getCurrentModelRef({ providerId: "anthropic", modelId: "claude-haiku" })).toBe("anthropic/claude-haiku");
expect(getCurrentModelRef({ provider: "openai" })).toBeUndefined();
});
it("formats the current model as the reviewer model ref", () => {
expect(getCurrentModelRef({ provider: "openai", id: "gpt-5" })).toBe(
"openai/gpt-5",
);
expect(
getCurrentModelRef({ providerId: "anthropic", modelId: "claude-haiku" }),
).toBe("anthropic/claude-haiku");
expect(getCurrentModelRef({ provider: "openai" })).toBeUndefined();
});
it("times out bounded child commands", async () => {
await expect(runRobotReviewCommand({
command: process.execPath,
args: ["-e", "setTimeout(() => {}, 1000)"],
}, undefined, 25)).rejects.toThrow(/timed out/i);
});
it("times out bounded child commands", async () => {
await expect(
runRobotReviewCommand(
{
command: process.execPath,
args: ["-e", "setTimeout(() => {}, 1000)"],
},
undefined,
25,
),
).rejects.toThrow(/timed out/i);
});
it("extracts assistant text from a child jsonl process", async () => {
const script = [
"process.stdout.write(JSON.stringify({type:'message_update'}) + '\\n');",
"process.stdout.write(JSON.stringify({type:'message_end',message:{role:'assistant',content:[{type:'text',text:'ROBOT_REVIEW_JSON_START {\\\"accepted\\\":true,\\\"observations\\\":[\\\"ok\\\"]} ROBOT_REVIEW_JSON_END'}]}}) + '\\n');",
].join("");
const result = await runRobotReviewCommand({
command: process.execPath,
args: ["-e", script],
}, undefined, 500);
expect(result.exitCode).toBe(0);
expect(result.stdout).toContain("ROBOT_REVIEW_JSON_END");
});
it("extracts assistant text from a child jsonl process", async () => {
const script = [
"process.stdout.write(JSON.stringify({type:'message_update'}) + '\\n');",
"process.stdout.write(JSON.stringify({type:'message_end',message:{role:'assistant',content:[{type:'text',text:'ROBOT_REVIEW_JSON_START {\\\"accepted\\\":true,\\\"observations\\\":[\\\"ok\\\"]} ROBOT_REVIEW_JSON_END'}]}}) + '\\n');",
].join("");
const result = await runRobotReviewCommand(
{
command: process.execPath,
args: ["-e", script],
},
undefined,
500,
);
expect(result.exitCode).toBe(0);
expect(result.stdout).toContain("ROBOT_REVIEW_JSON_END");
});
});
test/robot-review.test.ts
+418 -260
View File
@@ -2,288 +2,446 @@ import { mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
import { archiveCurrentEvidence, buildArtifactRecords, buildRobotReviewPrompt, getCurrentEvidenceIteration, getEvidenceHistory, renderEvidencePacket, renderProofLog } from "../src/index.js";
import { appendRobotReviewMetadata, getLatestRobotReview, getRobotReviews, hasCompleteProofClaim, relaxAdvisoryVerificationHints, shouldCompleteAfterAcceptedReview } from "../src/robot-review.js";
import {
archiveCurrentEvidence,
buildArtifactRecords,
buildRobotReviewPrompt,
getCurrentEvidenceIteration,
getEvidenceHistory,
renderEvidencePacket,
renderProofLog,
} from "../src/index.js";
import {
appendRobotReviewMetadata,
getLatestRobotReview,
getRobotReviews,
hasCompleteProofClaim,
relaxAdvisoryVerificationHints,
shouldCompleteAfterAcceptedReview,
} from "../src/robot-review.js";
import type { Task } from "../src/types.js";
function makeTask(overrides: Partial<Task> = {}): Task {
return {
id: "1",
subject: "Test",
description: "Desc",
done_criterion: "done",
status: "pending",
progress_label: undefined,
metadata: {},
blocks: [],
blockedBy: [],
createdAt: 0,
updatedAt: 0,
...overrides,
};
return {
id: "1",
subject: "Test",
description: "Desc",
done_criterion: "done",
status: "pending",
progress_label: undefined,
metadata: {},
blocks: [],
blockedBy: [],
createdAt: 0,
updatedAt: 0,
...overrides,
};
}
describe("robot review helpers", () => {
it("completes only after accepted review and complete proof claim", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong command",
lgtm_failure_sneaky: "right output for wrong reason",
lgtm_failure_unknown: "untested platform",
lgtm_falsification_test: "npm test\npass",
lgtm_evidence_reasoning: "the test output rules out the named failures for this scope",
lgtm_verification_hints: ["test/robot-review.test.ts shows the expectation"],
lgtm_remaining_uncertainty: "does not test prod install",
},
});
expect(hasCompleteProofClaim(task)).toBe(true);
expect(shouldCompleteAfterAcceptedReview(task, true)).toBe(true);
expect(shouldCompleteAfterAcceptedReview(task, false)).toBe(false);
expect(shouldCompleteAfterAcceptedReview(makeTask({ metadata: { lgtm_evidence: "literal output" } }), true)).toBe(false);
});
it("completes only after accepted review and complete proof claim", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong command",
lgtm_failure_sneaky: "right output for wrong reason",
lgtm_failure_unknown: "untested platform",
lgtm_falsification_test: "npm test\npass",
lgtm_evidence_reasoning:
"the test output rules out the named failures for this scope",
lgtm_verification_hints: [
"test/robot-review.test.ts shows the expectation",
],
lgtm_remaining_uncertainty: "does not test prod install",
},
});
expect(hasCompleteProofClaim(task)).toBe(true);
expect(shouldCompleteAfterAcceptedReview(task, true)).toBe(true);
expect(shouldCompleteAfterAcceptedReview(task, false)).toBe(false);
expect(
shouldCompleteAfterAcceptedReview(
makeTask({ metadata: { lgtm_evidence: "literal output" } }),
true,
),
).toBe(false);
});
it("reads legacy single-review metadata", () => {
const task = makeTask({
metadata: {
robot_review_reviewer: "opencode",
robot_review_scope: "task evidence",
robot_review_observations: ["Observed no command output for the core claim"],
robot_review_blind_spots: "Did not rerun tests",
robot_review_submitted_at: "2026-04-17T00:00:00.000Z",
},
});
it("reads legacy single-review metadata", () => {
const task = makeTask({
metadata: {
robot_review_reviewer: "opencode",
robot_review_scope: "task evidence",
robot_review_observations: [
"Observed no command output for the core claim",
],
robot_review_blind_spots: "Did not rerun tests",
robot_review_submitted_at: "2026-04-17T00:00:00.000Z",
},
});
const reviews = getRobotReviews(task);
expect(reviews).toHaveLength(1);
expect(reviews[0].reviewer).toBe("opencode");
expect(reviews[0].iteration).toBe(1);
expect(reviews[0].accepted).toBe(true);
});
const reviews = getRobotReviews(task);
expect(reviews).toHaveLength(1);
expect(reviews[0].reviewer).toBe("opencode");
expect(reviews[0].iteration).toBe(1);
expect(reviews[0].accepted).toBe(true);
});
it("builds artifact records with absolute path and sha256", () => {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-tasks-"));
const path = join(dir, "evidence.log");
writeFileSync(path, "hello\n");
it("builds artifact records with absolute path and sha256", () => {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-tasks-"));
const path = join(dir, "evidence.log");
writeFileSync(path, "hello\n");
const [artifact] = buildArtifactRecords([path]);
expect(artifact.path).toBe(path);
expect(artifact.bytes).toBe(6);
expect(artifact.sha256).toHaveLength(64);
});
const [artifact] = buildArtifactRecords([path]);
expect(artifact.path).toBe(path);
expect(artifact.bytes).toBe(6);
expect(artifact.sha256).toHaveLength(64);
});
it("archives current evidence with reason", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong seed",
lgtm_failure_sneaky: "wrong threshold",
lgtm_failure_unknown: "untested environment",
lgtm_falsification_test: "pytest -k check",
lgtm_evidence_reasoning: "pytest output distinguishes the expected passing path from the named failures",
lgtm_verification_hints: ["see line 5"],
lgtm_remaining_uncertainty: "not load tested",
lgtm_submitted_at: "2026-06-07T00:00:00.000Z",
lgtm_commands: [{ cmd: "pytest", exit_code: 0 }],
},
});
it("archives current evidence with reason", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong seed",
lgtm_failure_sneaky: "wrong threshold",
lgtm_failure_unknown: "untested environment",
lgtm_falsification_test: "pytest -k check",
lgtm_evidence_reasoning:
"pytest output distinguishes the expected passing path from the named failures",
lgtm_verification_hints: ["see line 5"],
lgtm_remaining_uncertainty: "not load tested",
lgtm_submitted_at: "2026-06-07T00:00:00.000Z",
lgtm_commands: [{ cmd: "pytest", exit_code: 0 }],
},
});
const archived = archiveCurrentEvidence(task, "threshold changed");
const taskWithHistory = makeTask({ metadata: archived });
expect(getCurrentEvidenceIteration(task)?.iteration).toBe(1);
expect(getEvidenceHistory(taskWithHistory)).toHaveLength(1);
expect(getEvidenceHistory(taskWithHistory)[0].supersede_reason).toBe("threshold changed");
});
const archived = archiveCurrentEvidence(task, "threshold changed");
const taskWithHistory = makeTask({ metadata: archived });
expect(getCurrentEvidenceIteration(task)?.iteration).toBe(1);
expect(getEvidenceHistory(taskWithHistory)).toHaveLength(1);
expect(getEvidenceHistory(taskWithHistory)[0].supersede_reason).toBe(
"threshold changed",
);
});
it("treats verification hints as advisory when core evidence already passes", () => {
const review = relaxAdvisoryVerificationHints({
reviewer: "auto",
scope: "task evidence",
observations: ["Observed commit, push, and test logs"],
concerns: [],
suggestions: [],
blind_spots: "Did not inspect interactive UI",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: ["verification_hints_actionable"],
submitted_at: "2026-06-13T00:00:00.000Z",
mode: "auto",
rubric: {
evidence_covers_done_criterion: { reason: "verbatim logs match", pass: true },
falsification_test_runnable: { reason: "command and output shown", pass: true },
failure_modes_addressed: { reason: "plausible top risks named", pass: true },
evidence_distinguishes_success: { reason: "evidence rules out named failures", pass: true },
verification_hints_actionable: { reason: "paths are vague", pass: false },
},
});
it("treats advisory rubric failures as non-blocking when core evidence already passes", () => {
const review = relaxAdvisoryVerificationHints({
reviewer: "auto",
scope: "task evidence",
observations: ["Observed commit, push, and test logs"],
concerns: [],
suggestions: [],
blind_spots: "Did not inspect interactive UI",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: [
"verification_hints_actionable",
"evidence_distinguishes_success",
],
submitted_at: "2026-06-13T00:00:00.000Z",
mode: "auto",
rubric: {
evidence_covers_done_criterion: {
reason: "verbatim logs match",
pass: true,
},
falsification_test_runnable: {
reason: "command and output shown",
pass: true,
},
failure_modes_addressed: {
reason: "plausible top risks named",
pass: true,
},
evidence_distinguishes_success: {
reason: "reasoning writeup is thin",
pass: false,
},
verification_hints_actionable: {
reason: "paths are vague",
pass: false,
},
},
});
expect(review.accepted).toBe(true);
expect(review.evidence_convincing).toBe(true);
expect(review.observations.at(-1)).toContain("treated as advisory");
expect(review.missing_evidence).toEqual([]);
});
expect(review.accepted).toBe(true);
expect(review.evidence_convincing).toBe(true);
expect(
review.observations.some((item) => item.includes("treated as advisory")),
).toBe(true);
expect(review.missing_evidence).toEqual([]);
});
it("does not relax verification hints unless the core rubric passes", () => {
const review = relaxAdvisoryVerificationHints({
reviewer: "auto",
scope: "task evidence",
observations: ["Observed vague summary only"],
concerns: [],
suggestions: [],
blind_spots: "Did not rerun tests",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: ["verification_hints_actionable"],
submitted_at: "2026-06-13T00:00:00.000Z",
mode: "auto",
rubric: {
evidence_covers_done_criterion: { reason: "summary only", pass: false },
falsification_test_runnable: { reason: "command and output shown", pass: true },
failure_modes_addressed: { reason: "plausible top risks named", pass: true },
evidence_distinguishes_success: { reason: "evidence does not rule out summary-only failure", pass: false },
verification_hints_actionable: { reason: "paths are vague", pass: false },
},
});
it("does not relax verification hints unless the core rubric passes", () => {
const review = relaxAdvisoryVerificationHints({
reviewer: "auto",
scope: "task evidence",
observations: ["Observed vague summary only"],
concerns: [],
suggestions: [],
blind_spots: "Did not rerun tests",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: ["verification_hints_actionable"],
submitted_at: "2026-06-13T00:00:00.000Z",
mode: "auto",
rubric: {
evidence_covers_done_criterion: { reason: "summary only", pass: false },
falsification_test_runnable: {
reason: "command and output shown",
pass: true,
},
failure_modes_addressed: {
reason: "plausible top risks named",
pass: true,
},
evidence_distinguishes_success: {
reason: "evidence does not rule out summary-only failure",
pass: false,
},
verification_hints_actionable: {
reason: "paths are vague",
pass: false,
},
},
});
expect(review.accepted).toBe(false);
expect(review.evidence_convincing).toBe(false);
});
expect(review.accepted).toBe(false);
expect(review.evidence_convincing).toBe(false);
});
it("renders one compact evidence packet for both human and robot review", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong seed",
lgtm_failure_sneaky: "wrong threshold",
lgtm_failure_unknown: "does not test UI rendering",
lgtm_falsification_test: "pytest -k check\nPASSED",
lgtm_evidence_reasoning: "The passing pytest transcript distinguishes success from wrong-threshold and wrong-seed failures for this test scope.",
lgtm_verification_hints: ["test/robot-review.test.ts contains the new guard test"],
lgtm_remaining_uncertainty: "not load tested",
lgtm_submitted_at: "2026-06-14T00:00:00.000Z",
lgtm_commands: [{ cmd: "npm test", exit_code: 0, stdout_path: "/tmp/test.log" }],
lgtm_evidence_artifacts: [{ path: "/tmp/test.log", sha256: "abc", bytes: 123 }],
},
});
it("renders one compact evidence packet for both human and robot review", () => {
const task = makeTask({
metadata: {
lgtm_evidence: "literal output",
lgtm_failure_likely: "wrong seed",
lgtm_failure_sneaky: "wrong threshold",
lgtm_failure_unknown: "does not test UI rendering",
lgtm_falsification_test: "pytest -k check\nPASSED",
lgtm_evidence_reasoning:
"The passing pytest transcript distinguishes success from wrong-threshold and wrong-seed failures for this test scope.",
lgtm_verification_hints: [
"test/robot-review.test.ts contains the new guard test",
],
lgtm_remaining_uncertainty: "not load tested",
lgtm_submitted_at: "2026-06-14T00:00:00.000Z",
lgtm_commands: [
{ cmd: "npm test", exit_code: 0, stdout_path: "/tmp/test.log" },
],
lgtm_evidence_artifacts: [
{ path: "/tmp/test.log", sha256: "abc", bytes: 123 },
],
},
});
const packet = renderEvidencePacket(task);
const prompt = buildRobotReviewPrompt(task);
expect(packet).toContain("## Goal");
expect(packet).toContain("## Planned evidence / UAT");
expect(packet).toContain("## Attempt 1");
expect(prompt).toContain(packet);
expect(prompt).toContain("does this evidence prove success for the stated goal");
});
const packet = renderEvidencePacket(task);
const prompt = buildRobotReviewPrompt(task);
expect(packet).toContain("## Goal");
expect(packet).toContain("## Attempt 1");
expect(packet).toContain("### Evidence");
expect(packet).toContain("### Verify");
expect(prompt).toContain(packet);
expect(prompt).toContain(
"does this packet prove the exact user-visible success condition",
);
expect(prompt).toContain(
"Do not reject solely because items 3, 4, or 5 are weak",
);
expect(prompt).toContain(
"concrete missing artifacts, command outputs, written-file checks",
);
});
it("appends robot reviews as iterations", () => {
const task = makeTask();
const metadata1 = appendRobotReviewMetadata(task, {
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing benchmark output"],
concerns: ["The current evidence does not show the claimed speedup."],
suggestions: ["Add the benchmark transcript for the claimed speedup."],
blind_spots: "Did not inspect prod config",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["Benchmark output for the claimed speedup"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "auto",
});
const task1 = makeTask({ metadata: metadata1 });
const metadata2 = appendRobotReviewMetadata(task1, {
reviewer: "opencode",
scope: "updated task evidence",
observations: ["Observed benchmark output and test transcript"],
concerns: [],
suggestions: [],
blind_spots: "Did not inspect long-run stability",
accepted: true,
evidence_complete: true,
evidence_convincing: true,
missing_evidence: [],
submitted_at: "2026-04-17T01:00:00.000Z",
mode: "auto",
});
it("truncates long submitted evidence in the rendered proof log and points to the full artifact", () => {
const longEvidence = Array.from(
{ length: 35 },
(_, i) => `line ${i + 1}`,
).join("\n");
const task = makeTask({
metadata: {
lgtm_evidence: longEvidence,
lgtm_failure_likely: "wrong seed",
lgtm_failure_sneaky: "wrong threshold",
lgtm_failure_unknown: "untested environment",
lgtm_falsification_test: "pytest -k check\nPASSED",
lgtm_evidence_reasoning:
"The transcript rules out the named failures for this scope.",
lgtm_verification_hints: ["see /tmp/test.log"],
lgtm_remaining_uncertainty: "not load tested",
lgtm_submitted_at: "2026-06-14T00:00:00.000Z",
lgtm_evidence_artifacts: [
{ path: "/tmp/test.log", sha256: "abc", bytes: 123 },
],
},
});
const task2 = makeTask({ metadata: metadata2 });
const reviews = getRobotReviews(task2);
expect(reviews).toHaveLength(2);
expect(reviews[0].iteration).toBe(1);
expect(reviews[1].iteration).toBe(2);
expect(getLatestRobotReview(task2)?.evidence_convincing).toBe(true);
expect(task2.metadata.robot_review_iteration_count).toBe(2);
});
const log = renderProofLog(task);
expect(log).toContain("line 1");
expect(log).toContain("line 8");
expect(log).toContain("line 35");
expect(log).not.toContain("line 9");
expect(log).toContain("[... 19 middle lines omitted ...]");
expect(log).toContain(
"[truncated at 16 lines from 35; showing first 8 and last 8; full text: /tmp/test.log]",
);
});
it("renders a simple proof log with judgement and suggestions", () => {
const taskWithEvidence = makeTask({
metadata: {
lgtm_evidence: "npm test\n125 passed",
lgtm_failure_likely: "old package name still in README",
lgtm_failure_sneaky: "top-level direct completion still slips through",
lgtm_failure_unknown: "fresh judge command fails in a real session",
lgtm_falsification_test: "npm test\n125 passed",
lgtm_evidence_reasoning: "The test transcript and grep distinguish the intended behavior from stale workflow regressions.",
lgtm_verification_hints: ["README.md install block shows pi-proof-tasks"],
lgtm_remaining_uncertainty: "Did not exercise every model provider.",
lgtm_submitted_at: "2026-06-14T00:00:00.000Z",
},
});
const task = makeTask({
metadata: {
...taskWithEvidence.metadata,
...appendRobotReviewMetadata(taskWithEvidence, {
reviewer: "auto",
scope: "proof log",
observations: ["Observed the test transcript and renamed package."],
concerns: ["The live Pi session path is still untested."],
suggestions: ["Run one self-hosted TaskClaimDone UAT."],
blind_spots: "Did not inspect external auth state",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: ["self-hosted TaskClaimDone UAT"],
submitted_at: "2026-06-14T00:01:00.000Z",
mode: "auto",
}),
},
});
it("appends robot reviews as iterations", () => {
const task = makeTask();
const metadata1 = appendRobotReviewMetadata(task, {
reviewer: "opencode",
scope: "task evidence",
observations: ["Observed missing benchmark output"],
concerns: ["The current evidence does not show the claimed speedup."],
suggestions: ["Add the benchmark transcript for the claimed speedup."],
blind_spots: "Did not inspect prod config",
accepted: false,
evidence_complete: false,
evidence_convincing: false,
missing_evidence: ["Benchmark output for the claimed speedup"],
submitted_at: "2026-04-17T00:00:00.000Z",
mode: "auto",
});
const task1 = makeTask({ metadata: metadata1 });
const metadata2 = appendRobotReviewMetadata(task1, {
reviewer: "opencode",
scope: "updated task evidence",
observations: ["Observed benchmark output and test transcript"],
concerns: [],
suggestions: [],
blind_spots: "Did not inspect long-run stability",
accepted: true,
evidence_complete: true,
evidence_convincing: true,
missing_evidence: [],
submitted_at: "2026-04-17T01:00:00.000Z",
mode: "auto",
});
const log = renderProofLog(task);
expect(log).toContain("# Task #1: Test");
expect(log).toContain("## Goal");
expect(log).toContain("## Planned evidence / UAT");
expect(log).toContain("## Attempt 1");
expect(log).toContain("### Submitted evidence");
expect(log).toContain("### Judgement");
expect(log).toContain("Refused by auto");
expect(log).toContain("Run one self-hosted TaskClaimDone UAT.");
});
const task2 = makeTask({ metadata: metadata2 });
const reviews = getRobotReviews(task2);
expect(reviews).toHaveLength(2);
expect(reviews[0].iteration).toBe(1);
expect(reviews[1].iteration).toBe(2);
expect(getLatestRobotReview(task2)?.evidence_convincing).toBe(true);
expect(task2.metadata.robot_review_iteration_count).toBe(2);
});
it("renders reviewer-unavailable proof logs for fail-open completion notes", () => {
const task = makeTask({
status: "completed",
metadata: {
lgtm_evidence: "npm test\n125 passed",
lgtm_failure_likely: "old package name still in README",
lgtm_failure_sneaky: "top-level direct completion still slips through",
lgtm_failure_unknown: "fresh judge command fails in a real session",
lgtm_falsification_test: "npm test\n125 passed",
lgtm_evidence_reasoning: "The test transcript and grep distinguish the intended behavior from stale workflow regressions.",
lgtm_verification_hints: ["README.md install block shows pi-proof-tasks"],
lgtm_remaining_uncertainty: "Did not exercise every model provider.",
robot_review_last_error: "judge auth failed",
},
});
it("renders a simple proof log with judgement and suggestions", () => {
const taskWithEvidence = makeTask({
metadata: {
lgtm_evidence: "npm test\n125 passed",
lgtm_failure_likely: "old package name still in README",
lgtm_failure_sneaky: "top-level direct completion still slips through",
lgtm_failure_unknown: "fresh judge command fails in a real session",
lgtm_falsification_test: "npm test\n125 passed",
lgtm_evidence_reasoning:
"The test transcript and grep distinguish the intended behavior from stale workflow regressions.",
lgtm_verification_hints: [
"README.md install block shows pi-proof-tasks",
],
lgtm_remaining_uncertainty: "Did not exercise every model provider.",
lgtm_submitted_at: "2026-06-14T00:00:00.000Z",
},
});
const task = makeTask({
metadata: {
...taskWithEvidence.metadata,
...appendRobotReviewMetadata(taskWithEvidence, {
reviewer: "auto",
scope: "proof log",
observations: ["Observed the test transcript and renamed package."],
concerns: ["The live Pi session path is still untested."],
suggestions: ["Run one self-hosted TaskClaimDone UAT."],
blind_spots: "Did not inspect external auth state",
accepted: false,
evidence_complete: true,
evidence_convincing: false,
missing_evidence: ["self-hosted TaskClaimDone UAT"],
submitted_at: "2026-06-14T00:01:00.000Z",
mode: "auto",
}),
},
});
const log = renderProofLog(task);
expect(log).toContain("completed with reviewer unavailable");
expect(log).toContain("### Judgement");
expect(log).toContain("judge auth failed");
expect(log).toContain("Autonomy continued without blocking completion.");
});
const log = renderProofLog(task);
expect(log).toContain("# Task #1: Test");
expect(log).toContain("## Goal");
expect(log).toContain("## Attempt 1");
expect(log).toContain("### Evidence");
expect(log).toContain("### Verify");
expect(log).toContain("### Judgement");
expect(log).toContain("Refused by auto");
expect(log).toContain("### Observations");
expect(log).toContain("### Concerns");
expect(log).toContain("### Missing evidence");
expect(log).toContain("### Suggestions");
expect(log).toContain("Run one self-hosted TaskClaimDone UAT.");
});
it("keeps full submitted evidence in the automatic review packet even when proof logs truncate it", () => {
const artifactPath = join(tmpdir(), "proof-packet-long-evidence.log");
const longEvidence = Array.from(
{ length: 35 },
(_, i) => `line ${i + 1}`,
).join("\n");
writeFileSync(artifactPath, longEvidence);
const task = makeTask({
metadata: {
lgtm_evidence: longEvidence,
lgtm_failure_likely: "missing artifact",
lgtm_failure_sneaky: "wrong slice shown",
lgtm_failure_unknown: "untested provider path",
lgtm_falsification_test: "npm test\npass",
lgtm_evidence_reasoning:
"The full evidence must stay visible to the judge even if humans see a shortened preview.",
lgtm_verification_hints: [
"Open the artifact if the inline preview truncates.",
],
lgtm_remaining_uncertainty: "Did not inspect live TUI.",
lgtm_evidence_artifacts: buildArtifactRecords([artifactPath]),
},
});
const proofLog = renderProofLog(task);
const reviewPacket = renderEvidencePacket(task, {
truncateEvidence: false,
});
expect(proofLog).toContain("line 8");
expect(proofLog).toContain("line 35");
expect(proofLog).not.toContain("line 9");
expect(reviewPacket).toContain("line 35");
expect(reviewPacket).not.toContain("[truncated at 16 lines");
});
it("renders reviewer-unavailable proof logs for fail-open completion notes", () => {
const task = makeTask({
status: "completed",
metadata: {
lgtm_evidence: "npm test\n125 passed",
lgtm_failure_likely: "old package name still in README",
lgtm_failure_sneaky: "top-level direct completion still slips through",
lgtm_failure_unknown: "fresh judge command fails in a real session",
lgtm_falsification_test: "npm test\n125 passed",
lgtm_evidence_reasoning:
"The test transcript and grep distinguish the intended behavior from stale workflow regressions.",
lgtm_verification_hints: [
"README.md install block shows pi-proof-tasks",
],
lgtm_remaining_uncertainty: "Did not exercise every model provider.",
robot_review_last_error: "judge auth failed",
},
});
const log = renderProofLog(task);
expect(log).toContain("completed with reviewer unavailable");
expect(log).toContain("### Judgement");
expect(log).toContain("judge auth failed");
expect(log).toContain("### Suggestions");
expect(log).not.toContain("### Missing evidence");
expect(log).not.toContain("### Observations");
expect(log).not.toContain("### Concerns");
expect(log).toContain("Autonomy continued without blocking completion.");
});
});
test/task-claim-done-flow.test.ts
+190
View File
@@ -0,0 +1,190 @@
import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import proofTasksExtension from "../src/index.js";
type RegisteredTool = {
name: string;
execute: (...args: any[]) => Promise<any>;
};
function makeHarness() {
const tools = new Map<string, RegisteredTool>();
const pi = {
on: vi.fn(),
registerTool: vi.fn((tool: RegisteredTool) => tools.set(tool.name, tool)),
registerCommand: vi.fn(),
sendMessage: vi.fn(),
};
proofTasksExtension(pi as any);
async function execTool(
name: string,
params: Record<string, unknown>,
ctx: Record<string, unknown> = {},
) {
const tool = tools.get(name);
if (!tool) throw new Error(`Tool ${name} not registered`);
return tool.execute("tool-call", params, undefined, undefined, ctx);
}
return { execTool };
}
function writeReviewerScript(source: string): string {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-reviewer-"));
const path = join(dir, "reviewer.js");
writeFileSync(path, `#!/usr/bin/env node\n${source}\n`);
chmodSync(path, 0o755);
return path;
}
const ORIGINAL_PI_BIN = process.env.PI_PROOF_TASKS_PI_BIN;
afterEach(() => {
if (ORIGINAL_PI_BIN === undefined) delete process.env.PI_PROOF_TASKS_PI_BIN;
else process.env.PI_PROOF_TASKS_PI_BIN = ORIGINAL_PI_BIN;
});
describe("TaskClaimDone end-to-end proof flow", () => {
it("keeps the task open on rejected review and /lgtm-style TaskGet shows truncated evidence", async () => {
const reviewer = writeReviewerScript(`
const review = {
reviewer: "fake-judge",
scope: "task evidence",
rubric: {
evidence_covers_done_criterion: { reason: "missing one artifact", pass: false },
falsification_test_runnable: { reason: "ok", pass: true },
failure_modes_addressed: { reason: "ok", pass: true },
evidence_distinguishes_success: { reason: "not enough", pass: false },
verification_hints_actionable: { reason: "ok", pass: true }
},
observations: ["Observed truncated proof packet"],
concerns: ["Need stronger evidence"],
suggestions: ["Add one more artifact"],
blind_spots: "Did not inspect live TUI",
missing_evidence: ["evidence_covers_done_criterion", "evidence_distinguishes_success"],
evidence_complete: false,
evidence_convincing: false,
accepted: false
};
console.log("ROBOT_REVIEW_JSON_START");
console.log(JSON.stringify(review));
console.log("ROBOT_REVIEW_JSON_END");
`);
process.env.PI_PROOF_TASKS_PI_BIN = reviewer;
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Proof task",
description: "Desc",
done_criterion: "done",
});
const artifactPath = join(tmpdir(), "proof-long-evidence.log");
const longEvidence = Array.from(
{ length: 35 },
(_, i) => `line ${i + 1}`,
).join("\n");
writeFileSync(artifactPath, longEvidence);
const claim = await harness.execTool(
"TaskClaimDone",
{
taskId: "1",
evidence: longEvidence,
failure_likely: "missing artifact",
failure_sneaky: "right shape for wrong reason",
failure_unknown: "untested provider path",
falsification_test: "npm test\npass",
evidence_reasoning:
"The packet distinguishes the named failures for this test scope.",
verification_hints: ["look at the proof log"],
remaining_uncertainty: "Did not inspect live TUI",
evidence_paths: [artifactPath],
},
{ model: { provider: "openai", id: "gpt-5" } },
);
const claimText = claim.content[0].text;
const taskGet = await harness.execTool("TaskGet", { taskId: "1" });
const text = taskGet.content[0].text;
expect(claimText).toContain("## TaskClaimDone -> Task #1: Proof task");
expect(claimText).toContain("### Metadata");
expect(claimText).toContain("- Proof iterations: 1");
expect(claimText).toContain("- Robot reviews: 1");
expect(text).toContain("Status: pending");
expect(text).toContain(
"Gate status: latest proof review rejected the evidence; strengthen the proof and try again",
);
expect(text).toContain("line 1");
expect(text).toContain("line 8");
expect(text).toContain("line 35");
expect(text).not.toContain("line 9");
expect(text).toContain("[... 19 middle lines omitted ...]");
expect(text).toContain(
`[truncated at 16 lines from 35; showing first 8 and last 8; full text: ${artifactPath}]`,
);
expect(text).toContain("### Judgement");
expect(text).toContain("Refused");
expect(text).toContain("### Missing evidence");
expect(text).toContain("### Suggestions");
expect(text).toContain("Add one more artifact");
});
it("completes the task fail-open on parse failure and preserves the failure note", async () => {
const reviewer = writeReviewerScript(`
console.log("ROBOT_REVIEW_JSON_START and nope ROBOT_REVIEW_JSON_END");
`);
process.env.PI_PROOF_TASKS_PI_BIN = reviewer;
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Proof task",
description: "Desc",
done_criterion: "done",
});
const claim = await harness.execTool(
"TaskClaimDone",
{
taskId: "1",
evidence: "short evidence",
failure_likely: "missing artifact",
failure_sneaky: "right shape for wrong reason",
failure_unknown: "untested provider path",
falsification_test: "npm test\npass",
evidence_reasoning:
"The packet distinguishes the named failures for this test scope.",
verification_hints: ["look at the proof log"],
remaining_uncertainty: "Did not inspect live TUI",
},
{ model: { provider: "openai", id: "gpt-5" } },
);
const claimText = claim.content[0].text;
const taskGet = await harness.execTool("TaskGet", { taskId: "1" });
const text = taskGet.content[0].text;
expect(claimText).toContain("## TaskClaimDone -> Task #1: Proof task");
expect(claimText).toContain("### Metadata");
expect(claimText).toContain(
"- Gate status: completed with reviewer unavailable",
);
expect(text).toContain("Status: completed");
expect(text).toContain("completed with reviewer unavailable");
expect(text).toContain("Raw output:");
expect(text).toContain("### Suggestions");
expect(text).not.toContain("### Missing evidence\n- (none)");
expect(text).not.toContain("### Observations\n- (none)");
expect(text).not.toContain("### Concerns\n- (none)");
expect(text).toContain(
"ROBOT_REVIEW_JSON_START and nope ROBOT_REVIEW_JSON_END",
);
expect(text).toContain("Autonomy continued without blocking completion.");
});
});
test/task-list-render.test.ts
+299 -86
View File
@@ -1,99 +1,312 @@
import { describe, expect, it, vi } from "vitest";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import proofTasksExtension from "../src/index.js";
import { TaskStore } from "../src/task-store.js";
type RegisteredTool = {
name: string;
execute: (...args: any[]) => Promise<any>;
name: string;
execute: (...args: any[]) => Promise<any>;
};
function makeHarness() {
const tools = new Map<string, RegisteredTool>();
const pi = {
on: vi.fn(),
registerTool: vi.fn((tool: RegisteredTool) => tools.set(tool.name, tool)),
registerCommand: vi.fn(),
sendMessage: vi.fn(),
};
const tools = new Map<string, RegisteredTool>();
const handlers = new Map<string, Array<(...args: any[]) => any>>();
const pi = {
on: vi.fn((event: string, handler: (...args: any[]) => any) => {
const existing = handlers.get(event) ?? [];
existing.push(handler);
handlers.set(event, existing);
}),
registerTool: vi.fn((tool: RegisteredTool) => tools.set(tool.name, tool)),
registerCommand: vi.fn(),
sendMessage: vi.fn(),
};
proofTasksExtension(pi as any);
proofTasksExtension(pi as any);
async function execTool(name: string, params: Record<string, unknown>) {
const tool = tools.get(name);
if (!tool) throw new Error(`Tool ${name} not registered`);
return tool.execute("tool-call", params, undefined, undefined, {});
}
async function execTool(name: string, params: Record<string, unknown>) {
const tool = tools.get(name);
if (!tool) throw new Error(`Tool ${name} not registered`);
return tool.execute("tool-call", params, undefined, undefined, {});
}
return { execTool };
async function trigger(event: string, payload: any = {}, ctx: any = {}) {
for (const handler of handlers.get(event) ?? []) {
await handler(payload, ctx);
}
}
return { execTool, trigger };
}
describe("TaskList", () => {
it("renders a compact one-line-per-task summary", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Design the flux capacitor",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Acquiring plutonium",
description: "Desc",
done_criterion: "done",
progress_label: "Acquiring plutonium",
});
await harness.execTool("TaskCreate", {
subject: "Install flux capacitor in DeLorean",
description: "Desc",
done_criterion: "done",
parentId: "1",
});
await harness.execTool("TaskCreate", {
subject: "Test time travel at 88 mph",
description: "Desc",
done_criterion: "done",
});
const tempDirs: string[] = [];
await harness.execTool("TaskUpdate", { taskId: "1", status: "completed" });
await harness.execTool("TaskUpdate", { taskId: "2", status: "in_progress" });
await harness.execTool("TaskUpdate", { taskId: "3", add_blocked_by: ["1"] });
await harness.execTool("TaskUpdate", { taskId: "4", add_blocked_by: ["2", "3"] });
const result = await harness.execTool("TaskList", {});
const text = result.content[0].text;
expect(text).toContain("● 4 tasks (1 in progress, 3 open)");
expect(text).toContain("◻ #1 Design the flux capacitor");
expect(text).toContain("◼ #2 Acquiring plutonium");
expect(text).toContain("◻ #3 Install flux capacitor in DeLorean › subtask of #1 › blocked by #1");
expect(text).toContain("◻ #4 Test time travel at 88 mph › blocked by #2, #3");
expect(text).not.toContain("[ACTIVE]");
expect(text).not.toContain("[PENDING]");
expect(text).not.toContain("[DONE");
expect(text).not.toContain("🛠");
expect(text).not.toContain("test:");
});
it("shows completed subtasks without proof-lane clutter", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Top-level goal",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Finished checklist item",
description: "Desc",
done_criterion: "done",
parentId: "1",
});
await harness.execTool("TaskUpdate", { taskId: "2", status: "completed" });
const result = await harness.execTool("TaskList", {});
const text = result.content[0].text;
expect(text).toContain("● 2 tasks (1 done, 1 open)");
expect(text).toContain("✔ #2 Finished checklist item › subtask of #1");
expect(text).not.toContain("[DONE");
expect(text).not.toContain("🛠");
});
afterEach(() => {
delete process.env.PI_TASKS;
while (tempDirs.length > 0)
rmSync(tempDirs.pop()!, { recursive: true, force: true });
});
describe("Task tools", () => {
it("renders a compact one-line-per-task summary", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Design the flux capacitor",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Acquiring plutonium",
description: "Desc",
done_criterion: "done",
progress_label: "Acquiring plutonium",
});
await harness.execTool("TaskCreate", {
subject: "Install flux capacitor in DeLorean",
description: "Desc",
done_criterion: "done",
parentId: "1",
});
await harness.execTool("TaskCreate", {
subject: "Test time travel at 88 mph",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskUpdate", { taskId: "1", status: "completed" });
await harness.execTool("TaskUpdate", {
taskId: "2",
status: "in_progress",
});
await harness.execTool("TaskUpdate", {
taskId: "3",
add_blocked_by: ["1"],
});
await harness.execTool("TaskUpdate", {
taskId: "4",
add_blocked_by: ["2", "3"],
});
const result = await harness.execTool("TaskList", {});
const text = result.content[0].text;
expect(text).toContain("● 4 goals (1 in progress, 3 open)");
expect(text).toContain("◻ #1 Design the flux capacitor");
expect(text).toContain("◼ #2 Acquiring plutonium");
expect(text).toContain(
"◻ #3 Install flux capacitor in DeLorean › subtask of #1 › blocked by #1",
);
expect(text).toContain(
"◻ #4 Test time travel at 88 mph › blocked by #2, #3",
);
expect(text).not.toContain("[ACTIVE]");
expect(text).not.toContain("[PENDING]");
expect(text).not.toContain("[DONE");
expect(text).not.toContain("proof claim submitted");
expect(text).not.toContain("test:");
});
it("shows TaskCreate output with metadata and compact previews", async () => {
const harness = makeHarness();
const result = await harness.execTool("TaskCreate", {
subject: "Top-level goal",
description: "Line 1\nLine 2\nLine 3",
done_criterion: "observe line a\nobserve line b",
progress_label: "Running check",
metadata: { owner: "pi", note: "short" },
});
const text = result.content[0].text;
expect(text).toContain("## TaskCreate -> Task #1: Top-level goal");
expect(text).toContain("### Metadata");
expect(text).toContain("- Metadata keys: 2");
expect(text).toContain("### Done criterion");
expect(text).toContain("### Description");
expect(text).toContain("### Progress label");
expect(text).toContain("### Metadata preview");
});
it("shows TaskUpdate output with changed fields and previews", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Top-level goal",
description: "Desc",
done_criterion: "done",
});
const result = await harness.execTool("TaskUpdate", {
taskId: "1",
status: "in_progress",
progress_label: "Running check",
metadata: { owner: "pi" },
});
const text = result.content[0].text;
expect(text).toContain("## TaskUpdate -> Task #1: Top-level goal");
expect(text).toContain(
"- Updated fields: status, progress_label, metadata",
);
expect(text).toContain("- status: pending -> in_progress");
expect(text).toContain("- progress_label: (missing) -> Running check");
expect(text).toContain("### Metadata patch");
});
it("shows completed subtasks without proof-lane clutter", async () => {
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Top-level goal",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Finished checklist item",
description: "Desc",
done_criterion: "done",
parentId: "1",
});
await harness.execTool("TaskUpdate", { taskId: "2", status: "completed" });
const result = await harness.execTool("TaskList", {});
const text = result.content[0].text;
expect(text).toContain("● 2 goals (1 done hidden, 1 open)");
expect(text).toContain("◻ #1 Top-level goal");
expect(text).not.toContain("#2 Finished checklist item");
expect(text).not.toContain("[DONE");
expect(text).not.toContain("proof claim submitted");
});
it("keeps persisted completed tasks on startup but hides them from the collapsed list", async () => {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-tasks-"));
tempDirs.push(dir);
const taskPath = join(dir, "tasks.json");
process.env.PI_TASKS = taskPath;
const seeded = new TaskStore(taskPath);
seeded.create("Finished work", "Desc", "done");
seeded.complete("1");
const harness = makeHarness();
await harness.trigger(
"before_agent_start",
{},
{
ui: { setWidget() {}, setStatus() {} },
sessionManager: { getSessionId: () => "session-test" },
},
);
const result = await harness.execTool("TaskList", {});
expect(result.content[0].text).toContain("● 1 goals (1 done hidden)");
expect(result.content[0].text).toContain(
"No open tasks. Completed tasks are hidden by default.",
);
const reloaded = new TaskStore(taskPath);
expect(reloaded.get("1")?.status).toBe("completed");
});
it("keeps persisted completed tasks on startup even when one open goal remains", async () => {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-tasks-"));
tempDirs.push(dir);
const taskPath = join(dir, "tasks.json");
process.env.PI_TASKS = taskPath;
const seeded = new TaskStore(taskPath);
seeded.create("Open goal", "Desc", "done");
seeded.create("Finished work", "Desc", "done", undefined, undefined, "1");
seeded.complete("2");
const harness = makeHarness();
await harness.trigger(
"before_agent_start",
{},
{
ui: { setWidget() {}, setStatus() {} },
sessionManager: { getSessionId: () => "session-test" },
},
);
const result = await harness.execTool("TaskList", {});
const text = result.content[0].text;
expect(text).toContain("● 2 goals (1 done hidden, 1 open)");
expect(text).toContain("◻ #1 Open goal");
expect(text).not.toContain("Finished work");
const reloaded = new TaskStore(taskPath);
expect(reloaded.get("2")?.status).toBe("completed");
});
it("keeps completed tasks persisted by default across later turns", async () => {
const dir = mkdtempSync(join(tmpdir(), "pi-proof-tasks-"));
tempDirs.push(dir);
const taskPath = join(dir, "tasks.json");
process.env.PI_TASKS = taskPath;
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Persistent completed goal",
description: "Desc",
done_criterion: "done",
});
await harness.execTool("TaskCreate", {
subject: "Checklist item",
description: "Desc",
done_criterion: "done",
parentId: "1",
});
await harness.execTool("TaskUpdate", { taskId: "2", status: "completed" });
for (let turn = 0; turn < 8; turn++) {
await harness.trigger("turn_start", {}, {
ui: { setWidget() {}, setStatus() {} },
sessionManager: { getSessionId: () => "session-test" },
});
}
const reloaded = new TaskStore(taskPath);
expect(reloaded.get("2")?.status).toBe("completed");
});
it("stores named PI_TASKS lists inside the repo .pi/tasks directory", async () => {
process.env.PI_TASKS = `named-${Date.now()}`;
const expectedPath = join(
process.cwd(),
".pi",
"tasks",
`${process.env.PI_TASKS}.json`,
);
try {
rmSync(expectedPath);
} catch {}
try {
rmSync(expectedPath + ".lock");
} catch {}
try {
rmSync(expectedPath + ".tmp");
} catch {}
const harness = makeHarness();
await harness.execTool("TaskCreate", {
subject: "Repo local task",
description: "Desc",
done_criterion: "done",
});
const reloaded = new TaskStore(expectedPath);
expect(reloaded.get("1")?.subject).toBe("Repo local task");
try {
rmSync(expectedPath);
} catch {}
try {
rmSync(expectedPath + ".lock");
} catch {}
try {
rmSync(expectedPath + ".tmp");
} catch {}
});
});
test/task-store.test.ts
+496 -433
View File
@@ -1,467 +1,530 @@
import { readFileSync, rmSync } from "node:fs";
import { homedir, tmpdir } from "node:os";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { TaskStore } from "../src/task-store.js";
// Helper: create a subtask, which can be ticked off directly.
function createSubtask(store: TaskStore, subject: string) {
const parent = store.create(`${subject} parent`, "Desc", "done criterion");
return store.create(subject, "Desc", "done criterion", undefined, undefined, parent.id);
const parent = store.create(`${subject} parent`, "Desc", "done criterion");
return store.create(
subject,
"Desc",
"done criterion",
undefined,
undefined,
parent.id,
);
}
describe("TaskStore (in-memory)", () => {
let store: TaskStore;
beforeEach(() => {
store = new TaskStore(); // no listId = in-memory
});
it("creates tasks with auto-incrementing IDs", () => {
const t1 = store.create("First task", "Description 1", "criterion 1");
const t2 = store.create("Second task", "Description 2", "criterion 2");
expect(t1.id).toBe("1");
expect(t2.id).toBe("2");
expect(t1.status).toBe("pending");
expect(t1.subject).toBe("First task");
expect(t1.description).toBe("Description 1");
expect(t1.done_criterion).toBe("criterion 1");
});
it("creates tasks with optional fields", () => {
const t = store.create("Task", "Desc", "done criterion", "Running task", { key: "value" });
expect(t.progress_label).toBe("Running task");
expect(t.metadata).toEqual({ key: "value" });
});
it("gets a task by ID", () => {
store.create("Test", "Desc", "done");
const task = store.get("1");
expect(task).toBeDefined();
expect(task!.subject).toBe("Test");
});
it("returns undefined for non-existent task", () => {
expect(store.get("999")).toBeUndefined();
});
it("lists all tasks sorted by ID", () => {
store.create("Task 3", "Desc", "done");
store.create("Task 1", "Desc", "done");
store.create("Task 2", "Desc", "done");
const tasks = store.list();
expect(tasks.map(t => t.id)).toEqual(["1", "2", "3"]);
});
it("updates task status", () => {
store.create("Test", "Desc", "done");
const { task, changedFields } = store.update("1", { status: "in_progress" });
expect(task!.status).toBe("in_progress");
expect(changedFields).toEqual(["status"]);
});
it("updates multiple fields at once", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", {
subject: "Updated subject",
description: "Updated desc",
metadata: { owner: "agent-1" },
});
expect(changedFields).toContain("subject");
expect(changedFields).toContain("description");
expect(changedFields).toContain("metadata");
const task = store.get("1")!;
expect(task.subject).toBe("Updated subject");
expect(task.metadata.owner).toBe("agent-1");
});
it("deletes a task with status: deleted", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", { status: "deleted" });
expect(changedFields).toEqual(["deleted"]);
expect(store.get("1")).toBeUndefined();
expect(store.list()).toHaveLength(0);
});
it("preserves ID counter after deletion", () => {
store.create("Task 1", "Desc", "done");
store.create("Task 2", "Desc", "done");
store.update("1", { status: "deleted" });
const t3 = store.create("Task 3", "Desc", "done");
expect(t3.id).toBe("3"); // Not "1" — counter continues
});
it("merges metadata with null key deletion", () => {
store.create("Test", "Desc", "done", undefined, { a: 1, b: 2, c: 3 });
store.update("1", { metadata: { b: null, d: 4 } });
const task = store.get("1")!;
expect(task.metadata).toEqual({ a: 1, c: 3, d: 4 });
});
it("sets up bidirectional blocks via add_blocks", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const t1 = store.get("1")!;
const t2 = store.get("2")!;
expect(t1.blocks).toContain("2");
expect(t2.blockedBy).toContain("1");
});
it("sets up bidirectional blocks via add_blocked_by", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
const t1 = store.get("1")!;
const t2 = store.get("2")!;
expect(t1.blocks).toContain("2");
expect(t2.blockedBy).toContain("1");
});
it("does not duplicate dependency edges", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.update("1", { add_blocks: ["2"] }); // duplicate
const t1 = store.get("1")!;
expect(t1.blocks.filter(id => id === "2")).toHaveLength(1);
});
it("cleans up dependency edges on deletion", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.update("1", { status: "deleted" });
const t2 = store.get("2")!;
expect(t2.blockedBy).toEqual([]);
});
it("clears completed tasks", () => {
store.create("Completed", "Desc", "done");
store.create("Pending", "Desc", "done");
store.complete("1");
const count = store.clearCompleted();
expect(count).toBe(1);
expect(store.list()).toHaveLength(1);
expect(store.list()[0].id).toBe("2");
});
it("allows TaskUpdate(status=completed) for subtasks", () => {
createSubtask(store, "Checklist item");
const { task, changedFields } = store.update("2", { status: "completed" });
expect(task!.status).toBe("completed");
expect(changedFields).toContain("status");
});
it("blocks TaskUpdate(status=completed) for top-level tasks", () => {
store.create("Goal", "Desc", "done");
expect(() => store.update("1", { status: "completed" })).toThrow("Top-level task #1 requires proof");
});
it("keeps top-level completion gated even after proof evidence exists", () => {
store.create("Escalated", "Desc", "done");
store.update("1", { metadata: { lgtm_evidence: "literal output" } });
expect(() => store.update("1", { status: "completed" })).toThrow("TaskClaimDone");
});
it("rejects changing parentId after creation", () => {
store.create("Parent", "Desc", "done");
store.create("Child", "Desc", "done");
expect(() => store.update("2", { parentId: "1" })).toThrow("parentId is creation-only");
});
it("returns not found for update on non-existent task", () => {
const { task, changedFields } = store.update("999", { status: "in_progress" });
expect(task).toBeUndefined();
expect(changedFields).toEqual([]);
});
it("complete() is the internal proof-review completion path", () => {
store.create("Test", "Desc", "done");
const task = store.complete("1");
expect(task.status).toBe("completed");
});
it("complete() also works for subtasks", () => {
createSubtask(store, "Test");
const task = store.complete("2");
expect(task.status).toBe("completed");
});
it("complete() throws on non-existent task", () => {
expect(() => store.complete("999")).toThrow("not found");
});
it("delete method works", () => {
store.create("Test", "Desc", "done");
expect(store.delete("1")).toBe(true);
expect(store.delete("1")).toBe(false); // already deleted
expect(store.list()).toHaveLength(0);
});
it("creates tasks with metadata via TaskCreate", () => {
const t = store.create("With meta", "Desc", "done", undefined, { pr: "123", reviewer: "alice" });
expect(t.metadata).toEqual({ pr: "123", reviewer: "alice" });
const retrieved = store.get("1")!;
expect(retrieved.metadata).toEqual({ pr: "123", reviewer: "alice" });
});
it("allows circular dependencies with warning", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const { warnings } = store.update("2", { add_blocks: ["1"] });
expect(store.get("1")!.blocks).toContain("2");
expect(store.get("2")!.blocks).toContain("1");
expect(warnings).toContain("cycle: #2 and #1 block each other");
});
it("allows self-dependency with warning", () => {
store.create("Self", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["1"] });
expect(store.get("1")!.blocks).toContain("1");
expect(warnings).toContain("#1 blocks itself");
});
it("stores dangling edge IDs with warning", () => {
store.create("Real", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["9999"] });
expect(store.get("1")!.blocks).toContain("9999");
expect(warnings).toContain("#9999 does not exist");
});
it("returns no warnings for valid dependencies", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["2"] });
expect(warnings).toEqual([]);
});
it("accepts whitespace-only subjects (matches Claude Code)", () => {
const t = store.create(" ", "Desc", "done");
expect(t.subject).toBe(" ");
});
it("updates progress_label field", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", { progress_label: "Running tests" });
expect(changedFields).toContain("progress_label");
expect(store.get("1")!.progress_label).toBe("Running tests");
});
it("updates description field", () => {
store.create("Test", "Original desc", "done");
const { changedFields } = store.update("1", { description: "Updated desc" });
expect(changedFields).toContain("description");
expect(store.get("1")!.description).toBe("Updated desc");
});
it("updates done_criterion field", () => {
store.create("Test", "Desc", "original criterion");
const { changedFields } = store.update("1", { done_criterion: "updated criterion" });
expect(changedFields).toContain("done_criterion");
expect(store.get("1")!.done_criterion).toBe("updated criterion");
});
it("returns empty changedFields when updating non-existent task", () => {
const { task, changedFields, warnings } = store.update("999", { status: "in_progress" });
expect(task).toBeUndefined();
expect(changedFields).toEqual([]);
expect(warnings).toEqual([]);
});
it("clearCompleted cleans up dependency edges", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
// complete() is the internal proof-review completion path.
store.complete("1");
store.clearCompleted();
const t2 = store.get("2")!;
expect(t2.blockedBy).toEqual([]);
});
it("handles multiple add_blocks in one call", () => {
store.create("Blocker", "Desc", "done");
store.create("B1", "Desc", "done");
store.create("B2", "Desc", "done");
store.update("1", { add_blocks: ["2", "3"] });
expect(store.get("1")!.blocks).toEqual(["2", "3"]);
expect(store.get("2")!.blockedBy).toContain("1");
expect(store.get("3")!.blockedBy).toContain("1");
});
it("add_blocked_by warns on self-dependency", () => {
store.create("Self", "Desc", "done");
const { warnings } = store.update("1", { add_blocked_by: ["1"] });
expect(store.get("1")!.blockedBy).toContain("1");
expect(warnings).toContain("#1 blocks itself");
});
it("add_blocked_by warns on dangling ref", () => {
store.create("Real", "Desc", "done");
const { warnings } = store.update("1", { add_blocked_by: ["9999"] });
expect(store.get("1")!.blockedBy).toContain("9999");
expect(warnings).toContain("#9999 does not exist");
});
it("add_blocked_by warns on cycle", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const { warnings } = store.update("1", { add_blocked_by: ["2"] });
expect(warnings).toContain("cycle: #1 and #2 block each other");
});
it("clearCompleted returns 0 when no completed tasks", () => {
store.create("Pending", "Desc", "done");
expect(store.clearCompleted()).toBe(0);
});
it("list sorts pending → in_progress → completed with all three present", () => {
store.create("Pending task", "Desc", "done");
store.create("Completed task", "Desc", "done");
store.create("In-progress task", "Desc", "done");
store.create("Another pending", "Desc", "done");
store.complete("2");
store.update("3", { status: "in_progress" });
const tasks = store.list();
const statusOrder: Record<string, number> = { pending: 0, in_progress: 1, completed: 2 };
const sorted = [...tasks].sort((a, b) => {
const so = (statusOrder[a.status] ?? 0) - (statusOrder[b.status] ?? 0);
if (so !== 0) return so;
return Number(a.id) - Number(b.id);
});
expect(sorted.map(t => t.id)).toEqual(["1", "4", "3", "2"]);
expect(sorted.map(t => t.status)).toEqual(["pending", "pending", "in_progress", "completed"]);
});
let store: TaskStore;
beforeEach(() => {
store = new TaskStore(); // no listId = in-memory
});
it("creates tasks with auto-incrementing IDs", () => {
const t1 = store.create("First task", "Description 1", "criterion 1");
const t2 = store.create("Second task", "Description 2", "criterion 2");
expect(t1.id).toBe("1");
expect(t2.id).toBe("2");
expect(t1.status).toBe("pending");
expect(t1.subject).toBe("First task");
expect(t1.description).toBe("Description 1");
expect(t1.done_criterion).toBe("criterion 1");
});
it("creates tasks with optional fields", () => {
const t = store.create("Task", "Desc", "done criterion", "Running task", {
key: "value",
});
expect(t.progress_label).toBe("Running task");
expect(t.metadata).toEqual({ key: "value" });
});
it("gets a task by ID", () => {
store.create("Test", "Desc", "done");
const task = store.get("1");
expect(task).toBeDefined();
expect(task!.subject).toBe("Test");
});
it("returns undefined for non-existent task", () => {
expect(store.get("999")).toBeUndefined();
});
it("lists all tasks sorted by ID", () => {
store.create("Task 3", "Desc", "done");
store.create("Task 1", "Desc", "done");
store.create("Task 2", "Desc", "done");
const tasks = store.list();
expect(tasks.map((t) => t.id)).toEqual(["1", "2", "3"]);
});
it("updates task status", () => {
store.create("Test", "Desc", "done");
const { task, changedFields } = store.update("1", {
status: "in_progress",
});
expect(task!.status).toBe("in_progress");
expect(changedFields).toEqual(["status"]);
});
it("updates multiple fields at once", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", {
subject: "Updated subject",
description: "Updated desc",
metadata: { owner: "agent-1" },
});
expect(changedFields).toContain("subject");
expect(changedFields).toContain("description");
expect(changedFields).toContain("metadata");
const task = store.get("1")!;
expect(task.subject).toBe("Updated subject");
expect(task.metadata.owner).toBe("agent-1");
});
it("deletes a task with status: deleted", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", { status: "deleted" });
expect(changedFields).toEqual(["deleted"]);
expect(store.get("1")).toBeUndefined();
expect(store.list()).toHaveLength(0);
});
it("preserves ID counter after deletion", () => {
store.create("Task 1", "Desc", "done");
store.create("Task 2", "Desc", "done");
store.update("1", { status: "deleted" });
const t3 = store.create("Task 3", "Desc", "done");
expect(t3.id).toBe("3"); // Not "1" — counter continues
});
it("merges metadata with null key deletion", () => {
store.create("Test", "Desc", "done", undefined, { a: 1, b: 2, c: 3 });
store.update("1", { metadata: { b: null, d: 4 } });
const task = store.get("1")!;
expect(task.metadata).toEqual({ a: 1, c: 3, d: 4 });
});
it("sets up bidirectional blocks via add_blocks", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const t1 = store.get("1")!;
const t2 = store.get("2")!;
expect(t1.blocks).toContain("2");
expect(t2.blockedBy).toContain("1");
});
it("sets up bidirectional blocks via add_blocked_by", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
const t1 = store.get("1")!;
const t2 = store.get("2")!;
expect(t1.blocks).toContain("2");
expect(t2.blockedBy).toContain("1");
});
it("does not duplicate dependency edges", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.update("1", { add_blocks: ["2"] }); // duplicate
const t1 = store.get("1")!;
expect(t1.blocks.filter((id) => id === "2")).toHaveLength(1);
});
it("cleans up dependency edges on deletion", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
store.update("1", { status: "deleted" });
const t2 = store.get("2")!;
expect(t2.blockedBy).toEqual([]);
});
it("clears completed tasks", () => {
store.create("Completed", "Desc", "done");
store.create("Pending", "Desc", "done");
store.complete("1");
const count = store.clearCompleted();
expect(count).toBe(1);
expect(store.list()).toHaveLength(1);
expect(store.list()[0].id).toBe("2");
});
it("allows TaskUpdate(status=completed) for subtasks", () => {
createSubtask(store, "Checklist item");
const { task, changedFields } = store.update("2", { status: "completed" });
expect(task!.status).toBe("completed");
expect(changedFields).toContain("status");
});
it("blocks TaskUpdate(status=completed) for top-level tasks", () => {
store.create("Goal", "Desc", "done");
expect(() => store.update("1", { status: "completed" })).toThrow(
"Top-level task #1 requires proof",
);
});
it("keeps top-level completion gated even after proof evidence exists", () => {
store.create("Escalated", "Desc", "done");
store.update("1", { metadata: { lgtm_evidence: "literal output" } });
expect(() => store.update("1", { status: "completed" })).toThrow(
"TaskClaimDone",
);
});
it("rejects changing parentId after creation", () => {
store.create("Parent", "Desc", "done");
store.create("Child", "Desc", "done");
expect(() => store.update("2", { parentId: "1" })).toThrow(
"parentId is creation-only",
);
});
it("returns not found for update on non-existent task", () => {
const { task, changedFields } = store.update("999", {
status: "in_progress",
});
expect(task).toBeUndefined();
expect(changedFields).toEqual([]);
});
it("complete() is the internal proof-review completion path", () => {
store.create("Test", "Desc", "done");
const task = store.complete("1");
expect(task.status).toBe("completed");
});
it("complete() also works for subtasks", () => {
createSubtask(store, "Test");
const task = store.complete("2");
expect(task.status).toBe("completed");
});
it("complete() throws on non-existent task", () => {
expect(() => store.complete("999")).toThrow("not found");
});
it("delete method works", () => {
store.create("Test", "Desc", "done");
expect(store.delete("1")).toBe(true);
expect(store.delete("1")).toBe(false); // already deleted
expect(store.list()).toHaveLength(0);
});
it("creates tasks with metadata via TaskCreate", () => {
const t = store.create("With meta", "Desc", "done", undefined, {
pr: "123",
reviewer: "alice",
});
expect(t.metadata).toEqual({ pr: "123", reviewer: "alice" });
const retrieved = store.get("1")!;
expect(retrieved.metadata).toEqual({ pr: "123", reviewer: "alice" });
});
it("allows circular dependencies with warning", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const { warnings } = store.update("2", { add_blocks: ["1"] });
expect(store.get("1")!.blocks).toContain("2");
expect(store.get("2")!.blocks).toContain("1");
expect(warnings).toContain("cycle: #2 and #1 block each other");
});
it("allows self-dependency with warning", () => {
store.create("Self", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["1"] });
expect(store.get("1")!.blocks).toContain("1");
expect(warnings).toContain("#1 blocks itself");
});
it("stores dangling edge IDs with warning", () => {
store.create("Real", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["9999"] });
expect(store.get("1")!.blocks).toContain("9999");
expect(warnings).toContain("#9999 does not exist");
});
it("returns no warnings for valid dependencies", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
const { warnings } = store.update("1", { add_blocks: ["2"] });
expect(warnings).toEqual([]);
});
it("accepts whitespace-only subjects (matches Claude Code)", () => {
const t = store.create(" ", "Desc", "done");
expect(t.subject).toBe(" ");
});
it("updates progress_label field", () => {
store.create("Test", "Desc", "done");
const { changedFields } = store.update("1", {
progress_label: "Running tests",
});
expect(changedFields).toContain("progress_label");
expect(store.get("1")!.progress_label).toBe("Running tests");
});
it("updates description field", () => {
store.create("Test", "Original desc", "done");
const { changedFields } = store.update("1", {
description: "Updated desc",
});
expect(changedFields).toContain("description");
expect(store.get("1")!.description).toBe("Updated desc");
});
it("updates done_criterion field", () => {
store.create("Test", "Desc", "original criterion");
const { changedFields } = store.update("1", {
done_criterion: "updated criterion",
});
expect(changedFields).toContain("done_criterion");
expect(store.get("1")!.done_criterion).toBe("updated criterion");
});
it("returns empty changedFields when updating non-existent task", () => {
const { task, changedFields, warnings } = store.update("999", {
status: "in_progress",
});
expect(task).toBeUndefined();
expect(changedFields).toEqual([]);
expect(warnings).toEqual([]);
});
it("clearCompleted cleans up dependency edges", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
// complete() is the internal proof-review completion path.
store.complete("1");
store.clearCompleted();
const t2 = store.get("2")!;
expect(t2.blockedBy).toEqual([]);
});
it("handles multiple add_blocks in one call", () => {
store.create("Blocker", "Desc", "done");
store.create("B1", "Desc", "done");
store.create("B2", "Desc", "done");
store.update("1", { add_blocks: ["2", "3"] });
expect(store.get("1")!.blocks).toEqual(["2", "3"]);
expect(store.get("2")!.blockedBy).toContain("1");
expect(store.get("3")!.blockedBy).toContain("1");
});
it("add_blocked_by warns on self-dependency", () => {
store.create("Self", "Desc", "done");
const { warnings } = store.update("1", { add_blocked_by: ["1"] });
expect(store.get("1")!.blockedBy).toContain("1");
expect(warnings).toContain("#1 blocks itself");
});
it("add_blocked_by warns on dangling ref", () => {
store.create("Real", "Desc", "done");
const { warnings } = store.update("1", { add_blocked_by: ["9999"] });
expect(store.get("1")!.blockedBy).toContain("9999");
expect(warnings).toContain("#9999 does not exist");
});
it("add_blocked_by warns on cycle", () => {
store.create("A", "Desc", "done");
store.create("B", "Desc", "done");
store.update("1", { add_blocks: ["2"] });
const { warnings } = store.update("1", { add_blocked_by: ["2"] });
expect(warnings).toContain("cycle: #1 and #2 block each other");
});
it("clearCompleted returns 0 when no completed tasks", () => {
store.create("Pending", "Desc", "done");
expect(store.clearCompleted()).toBe(0);
});
it("list sorts pending → in_progress → completed with all three present", () => {
store.create("Pending task", "Desc", "done");
store.create("Completed task", "Desc", "done");
store.create("In-progress task", "Desc", "done");
store.create("Another pending", "Desc", "done");
store.complete("2");
store.update("3", { status: "in_progress" });
const tasks = store.list();
const statusOrder: Record<string, number> = {
pending: 0,
in_progress: 1,
completed: 2,
};
const sorted = [...tasks].sort((a, b) => {
const so = (statusOrder[a.status] ?? 0) - (statusOrder[b.status] ?? 0);
if (so !== 0) return so;
return Number(a.id) - Number(b.id);
});
expect(sorted.map((t) => t.id)).toEqual(["1", "4", "3", "2"]);
expect(sorted.map((t) => t.status)).toEqual([
"pending",
"pending",
"in_progress",
"completed",
]);
});
});
describe("TaskStore (file-backed)", () => {
const testListId = `test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
const tasksDir = join(homedir(), ".pi", "tasks");
const filePath = join(tasksDir, `${testListId}.json`);
const testListId = `test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
const tasksDir = join(process.cwd(), ".pi", "tasks");
const filePath = join(tasksDir, `${testListId}.json`);
afterEach(() => {
try { rmSync(filePath); } catch { /* */ }
try { rmSync(filePath + ".lock"); } catch { /* */ }
try { rmSync(filePath + ".tmp"); } catch { /* */ }
});
afterEach(() => {
try {
rmSync(filePath);
} catch {
/* */
}
try {
rmSync(filePath + ".lock");
} catch {
/* */
}
try {
rmSync(filePath + ".tmp");
} catch {
/* */
}
});
it("persists tasks to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Persistent task", "Should survive reload", "done");
it("persists tasks to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Persistent task", "Should survive reload", "done");
const store2 = new TaskStore(testListId);
const tasks = store2.list();
const store2 = new TaskStore(testListId);
const tasks = store2.list();
expect(tasks).toHaveLength(1);
expect(tasks[0].subject).toBe("Persistent task");
});
expect(tasks).toHaveLength(1);
expect(tasks[0].subject).toBe("Persistent task");
});
it("persists in_progress updates to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Task", "Desc", "done");
store1.update("1", { status: "in_progress" });
it("persists in_progress updates to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Task", "Desc", "done");
store1.update("1", { status: "in_progress" });
const store2 = new TaskStore(testListId);
expect(store2.get("1")!.status).toBe("in_progress");
});
const store2 = new TaskStore(testListId);
expect(store2.get("1")!.status).toBe("in_progress");
});
it("persists completed tasks to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Done task", "Desc", "done");
store1.create("Pending task", "Desc", "done");
store1.complete("1");
it("persists completed tasks to disk", () => {
const store1 = new TaskStore(testListId);
store1.create("Done task", "Desc", "done");
store1.create("Pending task", "Desc", "done");
store1.complete("1");
const store2 = new TaskStore(testListId);
expect(store2.get("1")).toBeDefined();
expect(store2.get("1")!.status).toBe("completed");
expect(store2.get("2")).toBeDefined();
expect(store2.list()).toHaveLength(2);
});
const store2 = new TaskStore(testListId);
expect(store2.get("1")).toBeDefined();
expect(store2.get("1")!.status).toBe("completed");
expect(store2.get("2")).toBeDefined();
expect(store2.list()).toHaveLength(2);
});
it("restores all tasks across instances", () => {
const store1 = new TaskStore(testListId);
store1.create("Pending", "Desc", "done");
store1.create("In progress", "Desc", "done");
store1.create("Done", "Desc", "done");
store1.update("2", { status: "in_progress" });
store1.complete("3");
it("restores all tasks across instances", () => {
const store1 = new TaskStore(testListId);
store1.create("Pending", "Desc", "done");
store1.create("In progress", "Desc", "done");
store1.create("Done", "Desc", "done");
store1.update("2", { status: "in_progress" });
store1.complete("3");
const store2 = new TaskStore(testListId);
const tasks = store2.list();
expect(tasks).toHaveLength(3);
expect(tasks.map(t => t.id)).toContain("1");
expect(tasks.map(t => t.id)).toContain("2");
expect(tasks.map(t => t.id)).toContain("3");
});
const store2 = new TaskStore(testListId);
const tasks = store2.list();
expect(tasks).toHaveLength(3);
expect(tasks.map((t) => t.id)).toContain("1");
expect(tasks.map((t) => t.id)).toContain("2");
expect(tasks.map((t) => t.id)).toContain("3");
});
it("persists ID counter across instances", () => {
const store1 = new TaskStore(testListId);
store1.create("Task 1", "Desc", "done");
store1.create("Task 2", "Desc", "done");
it("persists ID counter across instances", () => {
const store1 = new TaskStore(testListId);
store1.create("Task 1", "Desc", "done");
store1.create("Task 2", "Desc", "done");
const store2 = new TaskStore(testListId);
const t3 = store2.create("Task 3", "Desc", "done");
expect(t3.id).toBe("3");
});
const store2 = new TaskStore(testListId);
const t3 = store2.create("Task 3", "Desc", "done");
expect(t3.id).toBe("3");
});
});
describe("TaskStore (absolute path)", () => {
const absFilePath = join(tmpdir(), `pi-tasks-test-${Date.now()}.json`);
const absFilePath = join(tmpdir(), `pi-tasks-test-${Date.now()}.json`);
afterEach(() => {
try { rmSync(absFilePath); } catch { /* */ }
try { rmSync(absFilePath + ".lock"); } catch { /* */ }
try { rmSync(absFilePath + ".tmp"); } catch { /* */ }
});
afterEach(() => {
try {
rmSync(absFilePath);
} catch {
/* */
}
try {
rmSync(absFilePath + ".lock");
} catch {
/* */
}
try {
rmSync(absFilePath + ".tmp");
} catch {
/* */
}
});
it("accepts absolute path and persists tasks", () => {
const store1 = new TaskStore(absFilePath);
store1.create("Abs path task", "Desc", "done");
it("accepts absolute path and persists tasks", () => {
const store1 = new TaskStore(absFilePath);
store1.create("Abs path task", "Desc", "done");
const store2 = new TaskStore(absFilePath);
expect(store2.list()).toHaveLength(1);
expect(store2.list()[0].subject).toBe("Abs path task");
});
const store2 = new TaskStore(absFilePath);
expect(store2.list()).toHaveLength(1);
expect(store2.list()[0].subject).toBe("Abs path task");
});
it("persists completed tasks when using absolute path", () => {
const store1 = new TaskStore(absFilePath);
store1.create("Pending", "Desc", "done");
store1.create("Completed", "Desc", "done");
store1.complete("2");
it("persists completed tasks when using absolute path", () => {
const store1 = new TaskStore(absFilePath);
store1.create("Pending", "Desc", "done");
store1.create("Completed", "Desc", "done");
store1.complete("2");
const raw = JSON.parse(readFileSync(absFilePath, "utf-8"));
expect(raw.tasks).toHaveLength(2);
});
const raw = JSON.parse(readFileSync(absFilePath, "utf-8"));
expect(raw.tasks).toHaveLength(2);
});
});
test/task-widget.test.ts
+336 -333
View File
@@ -4,425 +4,428 @@ import { TaskWidget, type Theme, type UICtx } from "../src/ui/task-widget.js";
/** Create a mock theme that returns raw text (no ANSI escapes). */
function mockTheme(): Theme {
return {
fg: (_color: string, text: string) => text,
bold: (text: string) => text,
strikethrough: (text: string) => `~~${text}~~`,
};
return {
fg: (_color: string, text: string) => text,
bold: (text: string) => text,
strikethrough: (text: string) => `~~${text}~~`,
};
}
/** Create a mock UICtx that captures setWidget calls. */
function mockUICtx() {
const state: {
widgets: Map<string, any>;
statuses: Map<string, string | undefined>;
} = {
widgets: new Map(),
statuses: new Map(),
};
const state: {
widgets: Map<string, any>;
statuses: Map<string, string | undefined>;
} = {
widgets: new Map(),
statuses: new Map(),
};
const ctx: UICtx = {
setWidget(key, content, options) {
state.widgets.set(key, { content, options });
},
setStatus(key, text) {
state.statuses.set(key, text);
},
};
const ctx: UICtx = {
setWidget(key, content, options) {
state.widgets.set(key, { content, options });
},
setStatus(key, text) {
state.statuses.set(key, text);
},
};
return { ctx, state };
return { ctx, state };
}
/** Render the widget and return its lines. */
function renderWidget(state: ReturnType<typeof mockUICtx>["state"]): string[] {
const entry = state.widgets.get("tasks");
if (!entry?.content) return [];
const theme = mockTheme();
const tui = { terminal: { columns: 200 }, requestRender() {} };
const result = entry.content(tui, theme);
return result.render();
const entry = state.widgets.get("tasks");
if (!entry?.content) return [];
const theme = mockTheme();
const tui = { terminal: { columns: 200 }, requestRender() {} };
const result = entry.content(tui, theme);
return result.render();
}
describe("TaskWidget", () => {
let store: TaskStore;
let widget: TaskWidget;
let ui: ReturnType<typeof mockUICtx>;
let store: TaskStore;
let widget: TaskWidget;
let ui: ReturnType<typeof mockUICtx>;
beforeEach(() => {
vi.useFakeTimers();
store = new TaskStore();
widget = new TaskWidget(store);
ui = mockUICtx();
widget.setUICtx(ui.ctx);
});
beforeEach(() => {
vi.useFakeTimers();
store = new TaskStore();
widget = new TaskWidget(store);
ui = mockUICtx();
widget.setUICtx(ui.ctx);
});
afterEach(() => {
widget.dispose();
vi.useRealTimers();
});
afterEach(() => {
widget.dispose();
vi.useRealTimers();
});
it("shows nothing when no tasks exist", () => {
widget.update();
const entry = ui.state.widgets.get("tasks");
expect(entry?.content).toBeUndefined();
});
it("shows nothing when no tasks exist", () => {
widget.update();
const entry = ui.state.widgets.get("tasks");
expect(entry?.content).toBeUndefined();
});
it("renders pending tasks with ◻ icon", () => {
store.create("Do something", "Desc", "done");
widget.update();
it("renders pending tasks with ◻ icon", () => {
store.create("Do something", "Desc", "done");
widget.update();
const lines = renderWidget(ui.state);
expect(lines).toHaveLength(2); // header + 1 task
expect(lines[0]).toContain("1 tasks");
expect(lines[0]).toContain("1 open");
expect(lines[1]).toContain("◻");
expect(lines[1]).toContain("Do something");
expect(lines[1]).not.toContain("done");
});
const lines = renderWidget(ui.state);
expect(lines).toHaveLength(2); // header + 1 task
expect(lines[0]).toContain("1 goals");
expect(lines[0]).toContain("1 open");
expect(lines[1]).toContain("◻");
expect(lines[1]).toContain("Do something");
expect(lines[1]).not.toContain("done");
});
it("renders in-progress tasks with ◼ icon", () => {
store.create("Working on it", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.update();
it("renders in-progress tasks with ◼ icon", () => {
store.create("Working on it", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("◼");
expect(lines[1]).toContain("Working on it");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("◼");
expect(lines[1]).toContain("Working on it");
});
it("renders completed tasks with ✔ icon and strikethrough", () => {
store.create("Done task", "Desc", "done");
store.complete("1");
widget.update();
it("hides the widget when only completed tasks remain", () => {
store.create("Done task", "Desc", "done");
store.complete("1");
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("✔");
expect(lines[1]).toContain("~~#1 Done task~~");
});
const lines = renderWidget(ui.state);
expect(lines).toEqual([]);
});
it("does not render proof badges on collapsed rows", () => {
store.create("Done task", "Desc", "done");
store.update("1", {
metadata: { robot_review_observations: ["Observed output drift on seed 2"], lgtm_evidence: "verbatim output" },
});
store.complete("1");
widget.update();
it("does not render proof badges on collapsed rows", () => {
store.create("Open task", "Desc", "done");
store.create("Done task", "Desc", "done");
store.update("2", {
metadata: {
robot_review_observations: ["Observed output drift on seed 2"],
lgtm_evidence: "verbatim output",
},
});
store.complete("2");
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).not.toContain("[");
expect(lines[1]).not.toContain("🛠");
expect(lines[1]).not.toContain("🤖");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("Open task");
expect(lines[1]).not.toContain("[");
expect(lines[1]).not.toContain("robot_review_observations");
expect(lines[1]).not.toContain("lgtm_evidence");
});
it("renders active tasks with spinner icon", () => {
store.create("Running thing", "Desc", "done criterion", "Processing data");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("renders active tasks with spinner icon", () => {
store.create("Running thing", "Desc", "done criterion", "Processing data");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
const lines = renderWidget(ui.state);
// Should show activeForm text with "…" suffix
expect(lines[1]).toContain("Processing data…");
// Should NOT show ◼ for active task
expect(lines[1]).not.toContain("◼");
});
const lines = renderWidget(ui.state);
// Should show activeForm text with "…" suffix
expect(lines[1]).toContain("Processing data…");
// Should NOT show ◼ for active task
expect(lines[1]).not.toContain("◼");
});
it("shows blocked-by info for pending tasks", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
widget.update();
it("shows blocked-by info for pending tasks", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
widget.update();
const lines = renderWidget(ui.state);
const blockedLine = lines.find(l => l.includes("Blocked"));
// blocked-by suffix is only added via dim theme helper, which in mock is identity
// So we should see the raw text. Check for the relevant subject line having blocked-by info
expect(blockedLine).toContain("blocked by #1");
});
const lines = renderWidget(ui.state);
const blockedLine = lines.find((l) => l.includes("Blocked"));
// blocked-by suffix is only added via dim theme helper, which in mock is identity
// So we should see the raw text. Check for the relevant subject line having blocked-by info
expect(blockedLine).toContain("blocked by #1");
});
it("hides completed blockers in blocked-by suffix", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
store.complete("1");
widget.update();
it("hides completed blockers in blocked-by suffix", () => {
store.create("Blocker", "Desc", "done");
store.create("Blocked", "Desc", "done");
store.update("2", { add_blocked_by: ["1"] });
store.complete("1");
widget.update();
const lines = renderWidget(ui.state);
const blockedLine = lines.find(l => l.includes("Blocked"));
expect(blockedLine).not.toContain("blocked by");
});
const lines = renderWidget(ui.state);
const blockedLine = lines.find((l) => l.includes("Blocked"));
expect(blockedLine).not.toContain("blocked by");
});
it("shows status summary in header", () => {
store.create("Task A", "Desc", "done");
store.create("Task B", "Desc", "done");
store.create("Task C", "Desc", "done");
store.complete("1");
store.update("2", { status: "in_progress" });
widget.update();
it("shows status summary in header", () => {
store.create("Task A", "Desc", "done");
store.create("Task B", "Desc", "done");
store.create("Task C", "Desc", "done");
store.complete("1");
store.update("2", { status: "in_progress" });
widget.update();
const lines = renderWidget(ui.state);
expect(lines[0]).toContain("3 tasks");
expect(lines[0]).toContain("1 done");
expect(lines[0]).toContain("1 in progress");
expect(lines[0]).toContain("1 open");
});
const lines = renderWidget(ui.state);
expect(lines[0]).toContain("3 goals");
expect(lines[0]).toContain("1 done hidden");
expect(lines[0]).toContain("1 in progress");
expect(lines[0]).toContain("1 open");
});
it("clears widget when all tasks are deleted", () => {
store.create("Task", "Desc", "done");
widget.update();
expect(ui.state.widgets.get("tasks")?.content).toBeDefined();
it("clears widget when all tasks are deleted", () => {
store.create("Task", "Desc", "done");
widget.update();
expect(ui.state.widgets.get("tasks")?.content).toBeDefined();
store.update("1", { status: "deleted" });
widget.update();
expect(ui.state.widgets.get("tasks")?.content).toBeUndefined();
});
store.update("1", { status: "deleted" });
widget.update();
expect(ui.state.widgets.get("tasks")?.content).toBeUndefined();
});
it("limits visible tasks to MAX_VISIBLE_TASKS", () => {
for (let i = 0; i < 15; i++) {
store.create(`Task ${i + 1}`, "Desc", "done");
}
widget.update();
it("limits visible tasks to MAX_VISIBLE_TASKS", () => {
for (let i = 0; i < 15; i++) {
store.create(`Task ${i + 1}`, "Desc", "done");
}
widget.update();
const lines = renderWidget(ui.state);
// header + 5 visible tasks + "...and 10 more"
expect(lines).toHaveLength(7);
expect(lines[6]).toContain("10 more");
});
const lines = renderWidget(ui.state);
// header + 5 visible tasks + "...and 10 more open"
expect(lines).toHaveLength(7);
expect(lines[6]).toContain("10 more open");
});
it("tracks token usage for active tasks", () => {
store.create("Active task", "Desc", "done criterion", "Running");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("tracks token usage for active tasks", () => {
store.create("Active task", "Desc", "done criterion", "Running");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.addTokenUsage(1000, 500);
widget.addTokenUsage(500, 300);
widget.addTokenUsage(1000, 500);
widget.addTokenUsage(500, 300);
const lines = renderWidget(ui.state);
const activeLine = lines.find(l => l.includes("Running…"));
expect(activeLine).toContain("↑ 1.5k");
expect(activeLine).toContain("↓ 800");
});
const lines = renderWidget(ui.state);
const activeLine = lines.find((l) => l.includes("Running…"));
expect(activeLine).toContain("↑ 1.5k");
expect(activeLine).toContain("↓ 800");
});
it("deactivates a task with setActiveTask(id, false)", () => {
store.create("Task", "Desc", "done criterion", "Doing work");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("deactivates a task with setActiveTask(id, false)", () => {
store.create("Task", "Desc", "done criterion", "Doing work");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
// Should be active (spinner)
let lines = renderWidget(ui.state);
expect(lines[1]).toContain("Doing work…");
// Should be active (spinner)
let lines = renderWidget(ui.state);
expect(lines[1]).toContain("Doing work…");
widget.setActiveTask("1", false);
lines = renderWidget(ui.state);
// Should now show as regular in_progress (◼)
expect(lines[1]).toContain("◼");
expect(lines[1]).not.toContain("Doing work…");
});
widget.setActiveTask("1", false);
lines = renderWidget(ui.state);
// Should now show as regular in_progress (◼)
expect(lines[1]).toContain("◼");
expect(lines[1]).not.toContain("Doing work…");
});
it("prunes stale active IDs on update", () => {
store.create("Task", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("prunes stale active IDs on update", () => {
store.create("Task", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
// Complete the task externally
store.complete("1");
widget.update();
// Complete the task externally
store.complete("1");
widget.update();
// Should render as completed, not active
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("✔");
expect(lines[1]).toContain("~~#1 Task~~");
});
// Completed tasks are hidden from the default widget
const lines = renderWidget(ui.state);
expect(lines).toEqual([]);
});
it("supports multiple active tasks simultaneously", () => {
store.create("Task A", "Desc", "done criterion", "Processing A");
store.create("Task B", "Desc", "done criterion", "Processing B");
store.update("1", { status: "in_progress" });
store.update("2", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.setActiveTask("2", true);
it("supports multiple active tasks simultaneously", () => {
store.create("Task A", "Desc", "done criterion", "Processing A");
store.create("Task B", "Desc", "done criterion", "Processing B");
store.update("1", { status: "in_progress" });
store.update("2", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.setActiveTask("2", true);
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("Processing A…");
expect(lines[2]).toContain("Processing B…");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("Processing A…");
expect(lines[2]).toContain("Processing B…");
});
it("distributes token usage across all active tasks", () => {
store.create("Task A", "Desc", "done criterion", "A");
store.create("Task B", "Desc", "done criterion", "B");
store.update("1", { status: "in_progress" });
store.update("2", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.setActiveTask("2", true);
it("distributes token usage across all active tasks", () => {
store.create("Task A", "Desc", "done criterion", "A");
store.create("Task B", "Desc", "done criterion", "B");
store.update("1", { status: "in_progress" });
store.update("2", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.setActiveTask("2", true);
widget.addTokenUsage(100, 50);
widget.addTokenUsage(100, 50);
const lines = renderWidget(ui.state);
// Both tasks should have the same token counts
expect(lines[1]).toContain("↑ 100");
expect(lines[2]).toContain("↑ 100");
});
const lines = renderWidget(ui.state);
// Both tasks should have the same token counts
expect(lines[1]).toContain("↑ 100");
expect(lines[2]).toContain("↑ 100");
});
it("dispose clears widget and timer", () => {
store.create("Task", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("dispose clears widget and timer", () => {
store.create("Task", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.dispose();
expect(ui.state.widgets.get("tasks")?.content).toBeUndefined();
});
widget.dispose();
expect(ui.state.widgets.get("tasks")?.content).toBeUndefined();
});
it("uses subject as fallback when no activeForm", () => {
store.create("My Subject", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("uses subject as fallback when no activeForm", () => {
store.create("My Subject", "Desc", "done");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("My Subject…");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("My Subject…");
});
it("shows elapsed time but no token arrows when tokens are zero", () => {
store.create("No tokens", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("shows elapsed time but no token arrows when tokens are zero", () => {
store.create("No tokens", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
// No addTokenUsage calls — tokens stay at 0
vi.advanceTimersByTime(5000);
widget.update();
// No addTokenUsage calls — tokens stay at 0
vi.advanceTimersByTime(5000);
widget.update();
const lines = renderWidget(ui.state);
const activeLine = lines.find(l => l.includes("Working…"));
expect(activeLine).toContain("5s");
expect(activeLine).not.toContain("↑");
expect(activeLine).not.toContain("↓");
});
const lines = renderWidget(ui.state);
const activeLine = lines.find((l) => l.includes("Working…"));
expect(activeLine).toContain("5s");
expect(activeLine).not.toContain("↑");
expect(activeLine).not.toContain("↓");
});
it("cleans up metrics when stale active IDs are pruned", () => {
store.create("Task", "Desc", "done criterion", "Running");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.addTokenUsage(100, 50);
it("cleans up metrics when stale active IDs are pruned", () => {
store.create("Task", "Desc", "done criterion", "Running");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.addTokenUsage(100, 50);
// Delete task externally
store.update("1", { status: "deleted" });
widget.update();
// Delete task externally
store.update("1", { status: "deleted" });
widget.update();
// Reactivate with same ID (new task) — should get fresh metrics
store.create("Task 2", "Desc", "done criterion", "Running"); // ID 2
store.update("2", { status: "in_progress" });
widget.setActiveTask("2", true);
// Reactivate with same ID (new task) — should get fresh metrics
store.create("Task 2", "Desc", "done criterion", "Running"); // ID 2
store.update("2", { status: "in_progress" });
widget.setActiveTask("2", true);
const lines = renderWidget(ui.state);
// Should not carry over old tokens
expect(lines[1]).not.toContain("↑ 100");
});
const lines = renderWidget(ui.state);
// Should not carry over old tokens
expect(lines[1]).not.toContain("↑ 100");
});
it("indents task lines under header", () => {
store.create("Indented task", "Desc", "done");
widget.update();
it("indents task lines under header", () => {
store.create("Indented task", "Desc", "done");
widget.update();
const lines = renderWidget(ui.state);
// Task line should start with 2 spaces
expect(lines[1]).toMatch(/^\s{2}/);
});
const lines = renderWidget(ui.state);
// Task line should start with 2 spaces
expect(lines[1]).toMatch(/^\s{2}/);
});
it("widget is placed aboveEditor", () => {
store.create("Task", "Desc", "done");
widget.update();
it("widget is placed aboveEditor", () => {
store.create("Task", "Desc", "done");
widget.update();
const entry = ui.state.widgets.get("tasks");
expect(entry?.options?.placement).toBe("aboveEditor");
});
const entry = ui.state.widgets.get("tasks");
expect(entry?.options?.placement).toBe("aboveEditor");
});
});
describe("formatDuration (via widget rendering)", () => {
let store: TaskStore;
let widget: TaskWidget;
let ui: ReturnType<typeof mockUICtx>;
let store: TaskStore;
let widget: TaskWidget;
let ui: ReturnType<typeof mockUICtx>;
beforeEach(() => {
vi.useFakeTimers();
store = new TaskStore();
widget = new TaskWidget(store);
ui = mockUICtx();
widget.setUICtx(ui.ctx);
});
beforeEach(() => {
vi.useFakeTimers();
store = new TaskStore();
widget = new TaskWidget(store);
ui = mockUICtx();
widget.setUICtx(ui.ctx);
});
afterEach(() => {
widget.dispose();
vi.useRealTimers();
});
afterEach(() => {
widget.dispose();
vi.useRealTimers();
});
it("shows seconds for short durations", () => {
store.create("Quick", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("shows seconds for short durations", () => {
store.create("Quick", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
vi.advanceTimersByTime(30_000); // 30s
widget.update();
vi.advanceTimersByTime(30_000); // 30s
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("30s");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("30s");
});
it("shows hours for long durations", () => {
store.create("Long", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("shows hours for long durations", () => {
store.create("Long", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
vi.advanceTimersByTime(3_723_000); // 1h 2m 3s → "1h 2m"
widget.update();
vi.advanceTimersByTime(3_723_000); // 1h 2m 3s → "1h 2m"
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("1h 2m");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("1h 2m");
});
it("shows exact hours without minutes", () => {
store.create("Exact", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("shows exact hours without minutes", () => {
store.create("Exact", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
vi.advanceTimersByTime(7_200_000); // 2h exactly
widget.update();
vi.advanceTimersByTime(7_200_000); // 2h exactly
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("2h)");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("2h)");
});
it("shows minutes and seconds", () => {
store.create("Medium", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("shows minutes and seconds", () => {
store.create("Medium", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
vi.advanceTimersByTime(169_000); // 2m 49s
widget.update();
vi.advanceTimersByTime(169_000); // 2m 49s
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("2m 49s");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("2m 49s");
});
it("formats small token counts without k suffix", () => {
store.create("Small", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("formats small token counts without k suffix", () => {
store.create("Small", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.addTokenUsage(500, 200);
widget.update();
widget.addTokenUsage(500, 200);
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("↑ 500");
expect(lines[1]).toContain("↓ 200");
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("↑ 500");
expect(lines[1]).toContain("↓ 200");
});
it("formats token counts with k suffix and removes .0", () => {
store.create("Large", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
it("formats token counts with k suffix and removes .0", () => {
store.create("Large", "Desc", "done criterion", "Working");
store.update("1", { status: "in_progress" });
widget.setActiveTask("1", true);
widget.addTokenUsage(2000, 4100);
widget.update();
widget.addTokenUsage(2000, 4100);
widget.update();
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("↑ 2k"); // 2000 → "2k" (not "2.0k")
expect(lines[1]).toContain("↓ 4.1k"); // 4100 → "4.1k"
});
const lines = renderWidget(ui.state);
expect(lines[1]).toContain("↑ 2k"); // 2000 → "2k" (not "2.0k")
expect(lines[1]).toContain("↓ 4.1k"); // 4100 → "4.1k"
});
});