sidecar-cli 0.1.6-beta.1 → 0.1.6-beta.2

package/dist/services/run-orchestrator-service.js

@@ -44,9 +44,9 @@ export async function runTaskExecution(input) {
     const prefs = loadRunnerPreferences(input.rootPath);
     const dryRun = Boolean(input.dryRun);
     const task = getTaskPacket(input.rootPath, input.taskId);
-    const runner = input.runner ?? task.tracking.assigned_runner ?? prefs.default_runner;
-    const agentRole = input.agentRole ?? task.tracking.assigned_agent_role ?? prefs.default_agent_role;
-    const worktree = (task.tracking.worktree ?? '').trim();
+    const runner = input.runner ?? prefs.default_runner;
+    const agentRole = input.agentRole ?? prefs.default_agent_role;
+    const worktree = '';
     let cwd;
     if (worktree.length > 0) {
         if (!fs.existsSync(worktree)) {
@@ -74,10 +74,10 @@ export async function runTaskExecution(input) {
     }
     const logPath = path.resolve(path.join(input.rootPath, '.sidecar', 'runs', 'logs', `${compiled.run_id}.log`));
     const adapter = getRunnerAdapter(runner);
-    saveTaskPacket(input.rootPath, { ...task, status: 'running' });
+    saveTaskPacket(input.rootPath, { ...task, status: 'active' });
     updateRunRecordEntry(input.rootPath, compiled.run_id, {
         status: 'running',
-        branch: task.tracking.branch,
+        branch: '',
         worktree: cwd,
     });
     const prepared = adapter.prepare({
@@ -107,13 +107,8 @@ export async function runTaskExecution(input) {
         changedFiles = await captureFilesChangedSince(cwd, preRunSnapshot);
     }
     if (!dryRun && collected.executed && ok) {
-        const configured = task.execution?.commands?.validation ?? [];
-        const steps = [];
-        for (const entry of configured) {
-            const normalized = normalizeValidationStep(entry);
-            if (normalized)
-                steps.push(normalized);
-        }
+        const normalized = normalizeValidationStep(task.validation_command);
+        const steps = normalized ? [normalized] : [];
         if (steps.length > 0) {
             validationAttempted = true;
             const results = await runValidationCommands(cwd, steps, logPath);
@@ -130,7 +125,7 @@ export async function runTaskExecution(input) {
         }
     }
     const finishedStatus = ok ? 'completed' : 'failed';
-    const nextTaskStatus = ok ? 'review' : 'blocked';
+    const nextTaskStatus = ok ? 'done' : 'blocked';
     // Auto-approve on all-green is opt-in via preferences. We only auto-approve when at least
     // one validation step actually ran and every step passed — a runner-only success with no
     // validation configured still requires a human click.

package/dist/services/run-review-service.js

@@ -4,14 +4,14 @@ import { getRunRecord, listRunRecords, updateRunRecordEntry } from '../runs/run-
 import { createTaskPacketRecord, getTaskPacket, saveTaskPacket } from '../tasks/task-service.js';
 function taskStatusForReview(state) {
     if (state === 'approved')
-        return 'review';
+        return 'active';
     if (state === 'needs_changes')
-        return 'ready';
+        return 'active';
     if (state === 'blocked')
         return 'blocked';
     if (state === 'merged')
         return 'done';
-    return 'review';
+    return 'active';
 }
 export function reviewRun(rootPath, runId, state, options) {
     const run = getRunRecord(rootPath, runId);
@@ -38,22 +38,21 @@ export function createFollowupTaskFromRun(rootPath, runId) {
     const run = getRunRecord(rootPath, runId);
     const sourceTask = getTaskPacket(rootPath, run.task_id);
     const suggestions = run.follow_ups.length > 0 ? run.follow_ups : ['Investigate run issues and apply required changes'];
+    const entryPoints = sourceTask.entry_points.length > 0
+        ? sourceTask.entry_points.slice(0, 3)
+        : run.changed_files.slice(0, 3).length > 0
+            ? run.changed_files.slice(0, 3)
+            : ['src/cli.ts'];
     const created = createTaskPacketRecord(rootPath, {
         title: `Follow-up: ${sourceTask.title}`,
         summary: run.review_note || run.summary || 'Follow-up work from reviewed run',
-        goal: suggestions.join('; '),
-        type: sourceTask.type,
-        status: 'draft',
+        status: 'active',
         priority: sourceTask.priority,
-        dependencies: [sourceTask.task_id],
-        tags: Array.from(new Set([...sourceTask.tags, 'follow-up'])),
-        target_areas: sourceTask.target_areas,
-        files_to_read: sourceTask.implementation.files_to_read,
-        files_to_avoid: sourceTask.implementation.files_to_avoid,
-        technical_constraints: sourceTask.constraints.technical,
-        design_constraints: sourceTask.constraints.design,
-        validation_commands: sourceTask.execution.commands.validation.map((v) => ({ ...v })),
-        definition_of_done: [...sourceTask.definition_of_done, ...suggestions],
+        trigger_condition: `After ${sourceTask.task_id} is done and this follow-up is explicitly scheduled`,
+        trigger_depends_on: [sourceTask.task_id],
+        entry_points: entryPoints,
+        done_condition: suggestions.join('; '),
+        validation_command: sourceTask.validation_command,
     });
     return {
         source_run_id: run.run_id,

package/dist/services/task-orchestration-service.js

@@ -1,24 +1,15 @@
-import { nowIso } from '../lib/format.js';
+import { spawnSync } from 'node:child_process';
 import { getTaskPacket, listTaskPackets, saveTaskPacket } from '../tasks/task-service.js';
 function hasUiSignal(task) {
-    const joined = [
-        ...task.tags,
-        ...task.target_areas,
-        ...task.implementation.files_to_read,
-        ...task.implementation.files_to_avoid,
-    ]
-        .join(' ')
-        .toLowerCase();
+    const joined = [task.title, task.summary, ...task.entry_points].join(' ').toLowerCase();
     return /(ui|frontend|css|html|react|view|component)/.test(joined);
 }
 function pickRole(task) {
-    if (task.type === 'research')
-        return { role: 'planner', reason: 'task type is research' };
-    if (task.tags.some((t) => t.toLowerCase() === 'test') || task.target_areas.some((a) => /test/i.test(a))) {
-        return { role: 'tester', reason: 'tags/target_areas indicate testing' };
+    if (/test|qa|verification|validate/i.test(task.title) || /test|qa|verification|validate/i.test(task.summary)) {
+        return { role: 'tester', reason: 'testing signal in title/summary' };
     }
-    if (task.tags.some((t) => /review/i.test(t)) || task.type === 'bug') {
-        return { role: 'reviewer', reason: 'bug/review signal present' };
+    if (/review|audit|risk|regression/i.test(task.title) || /review|audit|risk|regression/i.test(task.summary)) {
+        return { role: 'reviewer', reason: 'review signal in title/summary' };
     }
     if (hasUiSignal(task))
         return { role: 'builder-ui', reason: 'ui/frontend signal detected' };
@@ -30,26 +21,43 @@ function defaultRunnerForRole(role) {
     return 'codex';
 }
 export function dependenciesMet(task, tasksById) {
-    const missing = task.dependencies.filter((depId) => tasksById.get(depId)?.status !== 'done');
+    const deps = task.trigger.depends_on ?? [];
+    const missing = deps.filter((depId) => tasksById.get(depId)?.status !== 'done');
     return { ok: missing.length === 0, missing };
 }
+function triggerCommandSatisfied(rootPath, command) {
+    const proc = spawnSync(command, {
+        cwd: rootPath,
+        shell: true,
+        stdio: 'pipe',
+        encoding: 'utf8',
+    });
+    const ok = proc.status === 0;
+    const stderr = (proc.stderr || '').trim();
+    const stdout = (proc.stdout || '').trim();
+    if (ok)
+        return { ok: true, reason: `trigger check passed: ${command}` };
+    const details = stderr || stdout || `exit ${String(proc.status ?? '1')}`;
+    return { ok: false, reason: `trigger check failed: ${command} (${details})` };
+}
+export function evaluateTrigger(rootPath, task, tasksById) {
+    const dep = dependenciesMet(task, tasksById);
+    if (!dep.ok)
+        return { ok: false, reason: `dependencies not done: ${dep.missing.join(', ')}` };
+    const checkCommand = task.trigger.check_command?.trim();
+    if (checkCommand)
+        return triggerCommandSatisfied(rootPath, checkCommand);
+    if (task.trigger.depends_on.length > 0) {
+        return { ok: true, reason: 'dependency trigger satisfied' };
+    }
+    return { ok: false, reason: 'trigger requires user confirmation (no check command)' };
+}
 export function assignTask(rootPath, taskId, override) {
     const task = getTaskPacket(rootPath, taskId);
     const auto = pickRole(task);
     const role = override?.role ?? auto.role;
     const runner = override?.runner ?? defaultRunnerForRole(role);
     const reason = override?.role || override?.runner ? 'manual override' : auto.reason;
-    const updated = {
-        ...task,
-        tracking: {
-            ...task.tracking,
-            assigned_agent_role: role,
-            assigned_runner: runner,
-            assignment_reason: reason,
-            assigned_at: nowIso(),
-        },
-    };
-    saveTaskPacket(rootPath, updated);
     return { task_id: task.task_id, agent_role: role, runner, reason };
 }
 export function queueReadyTasks(rootPath) {
@@ -57,38 +65,17 @@ export function queueReadyTasks(rootPath) {
     const byId = new Map(tasks.map((t) => [t.task_id, t]));
     const decisions = [];
     for (const task of tasks) {
-        if (task.status !== 'ready')
+        if (task.status !== 'active')
             continue;
-        const dep = dependenciesMet(task, byId);
-        if (!dep.ok) {
-            saveTaskPacket(rootPath, { ...task, status: 'blocked' });
-            decisions.push({ task_id: task.task_id, queued: false, reason: `blocked by dependencies: ${dep.missing.join(', ')}` });
+        const trigger = evaluateTrigger(rootPath, task, byId);
+        if (!trigger.ok) {
+            if (task.trigger.depends_on.length > 0) {
+                saveTaskPacket(rootPath, { ...task, status: 'blocked' });
+            }
+            decisions.push({ task_id: task.task_id, queued: false, reason: trigger.reason });
             continue;
         }
-        const assignment = task.tracking.assigned_agent_role && task.tracking.assigned_runner
-            ? {
-                role: task.tracking.assigned_agent_role,
-                runner: task.tracking.assigned_runner,
-            }
-            : (() => {
-                const decided = assignTask(rootPath, task.task_id);
-                return { role: decided.agent_role, runner: decided.runner };
-            })();
-        const latest = getTaskPacket(rootPath, task.task_id);
-        saveTaskPacket(rootPath, {
-            ...latest,
-            status: 'queued',
-            tracking: {
-                ...latest.tracking,
-                assigned_agent_role: assignment.role,
-                assigned_runner: assignment.runner,
-            },
-        });
-        decisions.push({
-            task_id: task.task_id,
-            queued: true,
-            reason: `queued for ${assignment.role} via ${assignment.runner}`,
-        });
+        decisions.push({ task_id: task.task_id, queued: true, reason: trigger.reason });
     }
     return decisions;
 }

package/dist/services/task-status-service.js

@@ -1,13 +1,9 @@
 import { SidecarError } from '../lib/errors.js';
 import { getTaskPacket, saveTaskPacket } from '../tasks/task-service.js';
 const TASK_STATUS_TRANSITIONS = {
-    draft: ['ready', 'blocked', 'done'],
-    ready: ['draft', 'queued', 'blocked', 'done'],
-    queued: ['ready', 'running', 'blocked'],
-    running: ['ready', 'review', 'blocked'],
-    review: ['ready', 'blocked', 'done'],
-    blocked: ['ready', 'done'],
-    done: ['review'],
+    active: ['blocked', 'done'],
+    blocked: ['active', 'done'],
+    done: ['active'],
 };
 export function allowedTaskStatusTransitions(fromStatus) {
     return TASK_STATUS_TRANSITIONS[fromStatus];

package/dist/tasks/task-packet.js

@@ -1,148 +1,179 @@
 import { z } from 'zod';
-export const TASK_PACKET_VERSION = '1.0';
+import { nowIso } from '../lib/format.js';
+export const TASK_PACKET_VERSION = '2.0';
 const taskIdSchema = z.string().regex(/^T-\d{3,}$/, 'Task id must look like T-001');
-export const taskPacketStatusSchema = z.enum(['draft', 'ready', 'queued', 'running', 'review', 'blocked', 'done']);
+export const taskPacketStatusSchema = z.enum(['active', 'blocked', 'done']);
 export const taskPacketPrioritySchema = z.enum(['low', 'medium', 'high']);
-export const taskPacketTypeSchema = z.enum(['feature', 'bug', 'chore', 'research']);
-export const taskAgentRoleSchema = z.enum(['planner', 'builder-ui', 'builder-app', 'reviewer', 'tester']);
-export const taskRunnerSchema = z.enum(['codex', 'claude']);
-export const validationKindSchema = z.enum(['typecheck', 'lint', 'test', 'build', 'custom']);
-// Accept string entries ("npm test") or object entries ({kind,command,...}). String entries
-// are promoted to { kind: 'custom', command }. This preserves the v1 packet shape while
-// giving new packets first-class typed validation steps.
-export const validationStepSchema = z.preprocess((raw) => {
-    if (typeof raw === 'string') {
-        return { kind: 'custom', command: raw };
-    }
-    return raw;
-}, z
+export const taskTriggerSchema = z
     .object({
-    kind: validationKindSchema.default('custom'),
-    command: z.string().min(1, 'validation command is required'),
-    name: z.string().optional(),
-    timeout_ms: z.number().int().positive().optional(),
+    condition: z.string().min(1, 'trigger condition is required'),
+    check_command: z.string().min(1).optional(),
+    depends_on: z.array(taskIdSchema).default([]),
 })
-    .strict());
-export const taskPacketSchema = z
+    .strict();
+export const taskResultSchema = z
+    .object({
+    summary: z.string().default(''),
+    changed_files: z.array(z.string()).default([]),
+    validation_output: z.string().default(''),
+    validated_at: z.string().datetime({ offset: true }).nullable().default(null),
+})
+    .strict();
+function normalizeLegacyStatus(value) {
+    if (value === 'open')
+        return 'active';
+    if (value === 'in_progress')
+        return 'active';
+    if (value === 'draft' || value === 'ready' || value === 'queued' || value === 'running' || value === 'review')
+        return 'active';
+    return value;
+}
+function normalizeLegacyPacket(raw) {
+    if (!raw || typeof raw !== 'object')
+        return raw;
+    const packet = raw;
+    const entryFromLegacy = (() => {
+        const implementation = packet.implementation;
+        const files = implementation?.files_to_read;
+        if (Array.isArray(files)) {
+            return files
+                .map((v) => (typeof v === 'string' ? v.trim() : ''))
+                .filter((v) => v.length > 0)
+                .slice(0, 3);
+        }
+        return [];
+    })();
+    const doneFromLegacy = (() => {
+        const dod = packet.definition_of_done;
+        if (Array.isArray(dod) && dod.length > 0) {
+            const first = dod.find((v) => typeof v === 'string' && v.trim().length > 0);
+            if (typeof first === 'string')
+                return first.trim();
+        }
+        const goal = typeof packet.goal === 'string' ? packet.goal.trim() : '';
+        return goal;
+    })();
+    const validationFromLegacy = (() => {
+        const execution = packet.execution;
+        const commands = execution?.commands;
+        const validation = commands?.validation;
+        if (Array.isArray(validation) && validation.length > 0) {
+            const first = validation[0];
+            if (typeof first === 'string')
+                return first.trim();
+            if (first && typeof first === 'object') {
+                const command = first.command;
+                if (typeof command === 'string')
+                    return command.trim();
+            }
+        }
+        return '';
+    })();
+    const dependenciesFromLegacy = (() => {
+        const deps = packet.dependencies;
+        if (Array.isArray(deps)) {
+            return deps.filter((v) => typeof v === 'string' && /^T-\d{3,}$/.test(v));
+        }
+        return [];
+    })();
+    const baseSummary = typeof packet.summary === 'string' ? packet.summary.trim() : '';
+    const baseGoal = typeof packet.goal === 'string' ? packet.goal.trim() : '';
+    const baseTitle = typeof packet.title === 'string' ? packet.title.trim() : '';
+    const resultLegacy = (() => {
+        const result = packet.result;
+        if (!result || typeof result !== 'object')
+            return undefined;
+        const validationResults = Array.isArray(result.validation_results)
+            ? result.validation_results.filter((v) => typeof v === 'string')
+            : [];
+        return {
+            summary: typeof result.summary === 'string' ? result.summary : '',
+            changed_files: Array.isArray(result.changed_files)
+                ? result.changed_files.filter((v) => typeof v === 'string')
+                : [],
+            validation_output: validationResults.join('\n'),
+            validated_at: null,
+        };
+    })();
+    return {
+        version: typeof packet.version === 'string' ? packet.version : TASK_PACKET_VERSION,
+        task_id: packet.task_id,
+        title: baseTitle,
+        summary: baseSummary || baseGoal || baseTitle,
+        priority: packet.priority,
+        status: normalizeLegacyStatus(packet.status),
+        created_at: packet.created_at,
+        updated_at: packet.updated_at,
+        trigger: packet.trigger ?? {
+            condition: dependenciesFromLegacy.length > 0
+                ? `After dependencies are done: ${dependenciesFromLegacy.join(', ')}`
+                : 'Set explicit trigger before execution.',
+            depends_on: dependenciesFromLegacy,
+        },
+        entry_points: packet.entry_points ?? entryFromLegacy,
+        done_condition: packet.done_condition ?? doneFromLegacy,
+        validation_command: packet.validation_command ?? validationFromLegacy,
+        ...(resultLegacy ? { result: resultLegacy } : {}),
+    };
+}
+const taskPacketShapeSchema = z
     .object({
     version: z.string().default(TASK_PACKET_VERSION),
     task_id: taskIdSchema,
     title: z.string().min(1, 'title is required'),
-    type: taskPacketTypeSchema.default('chore'),
-    status: z
-        .preprocess((value) => {
-        if (value === 'open')
-            return 'draft';
-        if (value === 'in_progress')
-            return 'running';
-        return value;
-    }, taskPacketStatusSchema)
-        .default('draft'),
-    priority: taskPacketPrioritySchema.default('medium'),
     summary: z.string().min(1, 'summary is required'),
-    goal: z.string().min(1, 'goal is required'),
-    scope: z.object({
-        in_scope: z.array(z.string()).default([]),
-        out_of_scope: z.array(z.string()).default([]),
-    }),
-    context: z.object({
-        related_decisions: z.array(z.string()).default([]),
-        related_notes: z.array(z.string()).default([]),
-    }),
-    implementation: z.object({
-        files_to_read: z.array(z.string()).default([]),
-        files_to_avoid: z.array(z.string()).default([]),
-    }),
-    constraints: z.object({
-        technical: z.array(z.string()).default([]),
-        design: z.array(z.string()).default([]),
-    }),
-    execution: z.object({
-        commands: z.object({
-            validation: z.array(validationStepSchema).default([]),
-        }),
-    }),
-    dependencies: z.array(taskIdSchema).default([]),
-    tags: z.array(z.string()).default([]),
-    target_areas: z.array(z.string()).default([]),
-    definition_of_done: z.array(z.string()).default([]),
-    tracking: z.object({
-        branch: z.string().default(''),
-        worktree: z.string().default(''),
-        assigned_agent_role: taskAgentRoleSchema.nullable().default(null),
-        assigned_runner: taskRunnerSchema.nullable().default(null),
-        assignment_reason: z.string().default(''),
-        assigned_at: z.string().datetime({ offset: true }).nullable().default(null),
-    }),
-    result: z.object({
-        summary: z.string().default(''),
-        changed_files: z.array(z.string()).default([]),
-        validation_results: z.array(z.string()).default([]),
+    priority: taskPacketPrioritySchema.default('medium'),
+    status: z.preprocess(normalizeLegacyStatus, taskPacketStatusSchema).default('active'),
+    created_at: z.string().datetime({ offset: true }).default(() => nowIso()),
+    updated_at: z.string().datetime({ offset: true }).default(() => nowIso()),
+    trigger: taskTriggerSchema,
+    entry_points: z
+        .array(z.string().min(1))
+        .min(1, 'at least one entry point is required')
+        .max(3, 'entry points must be 1-3 files'),
+    done_condition: z.string().min(1, 'done condition is required'),
+    validation_command: z.string().min(1, 'validation command is required'),
+    result: taskResultSchema.default({
+        summary: '',
+        changed_files: [],
+        validation_output: '',
+        validated_at: null,
     }),
 })
     .strict();
-export const taskPacketInputSchema = taskPacketSchema.omit({ task_id: true }).partial({
+export const taskPacketSchema = z.preprocess(normalizeLegacyPacket, taskPacketShapeSchema);
+export const taskPacketInputSchema = taskPacketShapeSchema.omit({ task_id: true }).partial({
     version: true,
-    type: true,
-    status: true,
     priority: true,
-    scope: true,
-    context: true,
-    implementation: true,
-    constraints: true,
-    execution: true,
-    dependencies: true,
-    tags: true,
-    target_areas: true,
-    definition_of_done: true,
-    tracking: true,
+    status: true,
+    created_at: true,
+    updated_at: true,
     result: true,
 });
 export function createTaskPacket(taskId, input) {
+    const now = nowIso();
     const normalized = {
-        ...input,
         version: input.version ?? TASK_PACKET_VERSION,
         task_id: taskId,
-        type: input.type ?? 'chore',
-        status: input.status ?? 'draft',
+        title: input.title,
+        summary: input.summary,
         priority: input.priority ?? 'medium',
-        scope: {
-            in_scope: input.scope?.in_scope ?? [],
-            out_of_scope: input.scope?.out_of_scope ?? [],
-        },
-        context: {
-            related_decisions: input.context?.related_decisions ?? [],
-            related_notes: input.context?.related_notes ?? [],
-        },
-        implementation: {
-            files_to_read: input.implementation?.files_to_read ?? [],
-            files_to_avoid: input.implementation?.files_to_avoid ?? [],
-        },
-        constraints: {
-            technical: input.constraints?.technical ?? [],
-            design: input.constraints?.design ?? [],
-        },
-        execution: {
-            commands: {
-                validation: input.execution?.commands?.validation ?? [],
-            },
-        },
-        dependencies: input.dependencies ?? [],
-        tags: input.tags ?? [],
-        target_areas: input.target_areas ?? [],
-        definition_of_done: input.definition_of_done ?? [],
-        tracking: {
-            branch: input.tracking?.branch ?? '',
-            worktree: input.tracking?.worktree ?? '',
-            assigned_agent_role: input.tracking?.assigned_agent_role ?? null,
-            assigned_runner: input.tracking?.assigned_runner ?? null,
-            assignment_reason: input.tracking?.assignment_reason ?? '',
-            assigned_at: input.tracking?.assigned_at ?? null,
+        status: input.status ?? 'active',
+        created_at: input.created_at ?? now,
+        updated_at: input.updated_at ?? now,
+        trigger: {
+            condition: input.trigger?.condition ?? '',
+            ...(input.trigger?.check_command ? { check_command: input.trigger.check_command } : {}),
+            depends_on: input.trigger?.depends_on ?? [],
         },
+        entry_points: input.entry_points ?? [],
+        done_condition: input.done_condition ?? '',
+        validation_command: input.validation_command ?? '',
         result: {
             summary: input.result?.summary ?? '',
             changed_files: input.result?.changed_files ?? [],
-            validation_results: input.result?.validation_results ?? [],
+            validation_output: input.result?.validation_output ?? '',
+            validated_at: input.result?.validated_at ?? null,
         },
     };
     return taskPacketSchema.parse(normalized);