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

package/README.md

@@ -200,9 +200,9 @@ Notes, decisions, worklogs:
 
 Tasks:
 
-- `sidecar task create --title "<title>" --summary "<summary>" --goal "<goal>" [--type feature|bug|chore|research] [--status draft|ready|queued|running|review|blocked|done] [--priority low|medium|high] [--json]`
-- `sidecar task set-status <task-id> --to draft|ready|queued|running|review|blocked|done --reason "<text>" [--by human|agent] [--session <id>] [--json]`
-- `sidecar task list [--status draft|ready|queued|running|review|blocked|done|all] [--json]`
+- `sidecar task create --title "<title>" --summary "<summary>" --trigger "<condition>" --entry-points <path1,path2> --done-condition "<done>" --validate-cmd "<cmd>" [--trigger-check <command>] [--depends-on <task-ids>] [--status active|blocked|done] [--priority low|medium|high] [--json]`
+- `sidecar task set-status <task-id> --to active|blocked|done --reason "<text>" [--by human|agent] [--session <id>] [--json]`
+- `sidecar task list [--status active|blocked|done|all] [--json]`
 
 Sessions:
 
@@ -217,47 +217,21 @@ Artifacts:
 - `sidecar artifact add <path> [--kind file|doc|screenshot|other] [--note <text>] [--json]`
 - `sidecar artifact list [--json]`
 
-## Validation kinds and auto-approve
+## Validation and auto-approve
 
-Task packets describe post-run validation commands under `execution.commands.validation`. Each entry is tagged with a **kind** so Sidecar can route the result intelligently, apply a sensible default timeout, and surface the outcome in the UI and CLI.
-
-### Kinds
-
-| Kind | Default timeout | Intended for |
-| --- | --- | --- |
-| `typecheck` | 3 min | `tsc --noEmit`, `mypy`, `pyright` |
-| `lint` | 3 min | `eslint`, `ruff`, `golangci-lint` |
-| `test` | 10 min | unit/integration suites |
-| `build` | 10 min | bundlers, compilers, image builds |
-| `custom` | 5 min | anything else (the legacy default) |
-
-### Authoring
-
-On the CLI, prefix a command with `kind:`. Entries without a prefix default to `custom`.
+Queue tasks now store one required `validation_command` that agents run to
+verify the done condition.
 
 ```bash
 sidecar task create \
   --title "Add import flow" \
-  --summary "..." --goal "..." \
-  --validate-cmds "typecheck:tsc --noEmit,lint:eslint .,test:npm test"
+  --summary "..." \
+  --trigger "After T-012 lands" --depends-on T-012 \
+  --entry-points src/cli.ts,src/tasks/task-packet.ts \
+  --done-condition "Task packets persist in active/blocked/done folders" \
+  --validate-cmd "npm run build"
 ```
 
-In a task packet JSON file, use the object form:
-
-```json
-"execution": {
-  "commands": {
-    "validation": [
-      { "kind": "typecheck", "command": "tsc --noEmit" },
-      { "kind": "test", "command": "npm test", "timeout_ms": 900000 },
-      "bash scripts/smoke.sh"
-    ]
-  }
-}
-```
-
-String entries are accepted for back-compat (promoted to `{ kind: "custom", command }` on load).
-
 ### Auto-approve on all-green
 
 When every validation step passes for a run, Sidecar can auto-approve the run so you don't have to click through the review queue for a strictly-green outcome. It's opt-in:
@@ -434,7 +408,7 @@ sidecar context --format markdown
 sidecar session start --actor agent --name codex
 sidecar decision record --title "Use SQLite" --summary "Local-first persistence"
 sidecar worklog record --goal "init flow" --done "Implemented schema and command surface" --files src/cli.ts,src/db/schema.ts
-sidecar task create --title "Add integration tests" --summary "Add integration coverage for init flow" --goal "Ensure init flow has regression coverage" --priority medium
+sidecar task create --title "Add integration tests" --summary "Add integration coverage for init flow" --trigger "When test matrix is finalized" --entry-points src/cli.ts --done-condition "Integration suite covers init flow" --validate-cmd "npm test" --priority medium
 sidecar summary refresh
 sidecar session end --summary "Initialization and recording flow implemented"
 ```

package/dist/cli.js

@@ -32,7 +32,7 @@ import { renderClaudeCodeHooksJson } from './templates/hooks.js';
 import { eventIngestSchema, ingestEvent } from './services/event-ingest-service.js';
 import { buildExportJson, buildExportJsonlEvents, writeOutputFile } from './services/export-service.js';
 import { createTaskPacketRecord, getTaskPacket, listTaskPackets } from './tasks/task-service.js';
-import { taskPacketPrioritySchema, taskPacketStatusSchema, taskPacketTypeSchema } from './tasks/task-packet.js';
+import { taskPacketPrioritySchema, taskPacketStatusSchema } from './tasks/task-packet.js';
 import { getRunRecord, listRunRecords, listRunRecordsForTask } from './runs/run-service.js';
 import { runStatusSchema, runnerTypeSchema } from './runs/run-record.js';
 import { compileTaskPrompt } from './prompts/prompt-service.js';
@@ -44,19 +44,15 @@ import { buildReviewSummary, createFollowupTaskFromRun, reviewRun } from './serv
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const actorSchema = z.enum(['human', 'agent']);
 const artifactKindSchema = z.enum(['file', 'doc', 'screenshot', 'other']);
-const taskListStatusSchema = z.enum(['draft', 'ready', 'queued', 'running', 'review', 'blocked', 'done', 'all']);
+const taskListStatusSchema = z.enum(['active', 'blocked', 'done', 'all']);
 const runListStatusSchema = runStatusSchema.or(z.literal('all'));
 const agentRoleSchema = z.enum(['planner', 'builder-ui', 'builder-app', 'reviewer', 'tester']);
 const exportFormatSchema = z.enum(['json', 'jsonl']);
 const NOT_INITIALIZED_MSG = 'Sidecar is not initialized in this directory or any parent directory';
 function formatStatus(value) {
     const v = value.toLowerCase();
-    if (v === 'ready' || v === 'draft')
+    if (v === 'active')
         return c.cyan(value);
-    if (v === 'running' || v === 'queued')
-        return c.yellow(value);
-    if (v === 'review')
-        return c.magenta(value);
     if (v === 'blocked')
         return c.red(value);
     if (v === 'done' || v === 'merged' || v === 'approved')
@@ -545,15 +541,12 @@ program
         const created = createTaskPacketRecord(demoRoot, {
             title: 'Add welcome banner',
             summary: 'Show a friendly greeting on first launch so new users know the tool is working.',
-            goal: 'Render a configurable banner at the top of the home page.',
-            type: 'feature',
-            status: 'ready',
+            status: 'active',
             priority: 'medium',
-            scope_in_scope: ['Render banner component', 'Wire to /home route'],
-            scope_out_of_scope: ['Dismissal persistence'],
-            files_to_read: ['src/pages/home.tsx'],
-            definition_of_done: ['Banner visible on load', 'No layout shift'],
-            validation_commands: ['typecheck@30s:tsc --noEmit', 'test@2m:npm test'],
+            trigger_condition: 'PM approved onboarding polish for next release',
+            entry_points: ['src/pages/home.tsx', 'src/components/Banner.tsx'],
+            done_condition: 'Banner is visible on first launch with no layout shift.',
+            validation_command: 'npm run build',
         });
         log(c.green('  ✓ ') + `${created.task.task_id} — ${created.task.title}`);
         log(c.dim(`     packet: ${path.relative(demoRoot, created.path)}`));
@@ -1000,76 +993,70 @@ worklog
 const task = program.command('task').description('Task commands');
 task
     .command('create')
-    .description('Create a structured task packet')
+    .description('Create an agent-ready queue task')
     .option('--title <title>', 'Task title')
-    .option('--type <type>', 'feature|bug|chore|research', 'chore')
-    .option('--status <status>', 'draft|ready|queued|running|review|blocked|done', 'draft')
+    .option('--status <status>', 'active|blocked|done', 'active')
     .option('--priority <priority>', 'low|medium|high', 'medium')
     .option('--summary <summary>', 'Task summary')
-    .option('--goal <goal>', 'Task goal')
-    .option('--dependencies <task-ids>', 'Comma-separated dependency task IDs')
-    .option('--tags <tags>', 'Comma-separated tags')
-    .option('--target-areas <areas>', 'Comma-separated target areas')
-    .option('--scope-in <items>', 'Comma-separated in-scope items')
-    .option('--scope-out <items>', 'Comma-separated out-of-scope items')
-    .option('--related-decisions <items>', 'Comma-separated related decision IDs/titles')
-    .option('--related-notes <items>', 'Comma-separated related notes')
-    .option('--files-read <paths>', 'Comma-separated files to read')
-    .option('--files-avoid <paths>', 'Comma-separated files to avoid')
-    .option('--constraint-tech <items>', 'Comma-separated technical constraints')
-    .option('--constraint-design <items>', 'Comma-separated design constraints')
-    .option('--validate-cmds <commands>', 'Comma-separated validation commands. Use "kind:command" to tag (typecheck|lint|test|build|custom), e.g. "typecheck:tsc --noEmit,test:npm test". Append "@30s" / "@2m" / "@1500ms" to the kind to override the timeout, e.g. "test@2m:npm test".')
-    .option('--dod <items>', 'Comma-separated definition-of-done checks')
-    .option('--branch <name>', 'Branch name')
-    .option('--worktree <path>', 'Worktree path')
+    .option('--trigger <condition>', 'Concrete trigger condition that makes this task ready')
+    .option('--trigger-check <command>', 'Command that returns 0 when the trigger is satisfied')
+    .option('--depends-on <task-ids>', 'Comma-separated dependency task IDs for trigger gating')
+    .option('--entry-points <paths>', 'Comma-separated 1-3 files to open first')
+    .option('--done-condition <text>', 'Observable condition that proves this task is done')
+    .option('--validate-cmd <command>', 'Command to validate the done condition')
     .option('--json', 'Print machine-readable JSON output')
-    .addHelpText('after', '\nExamples:\n  $ sidecar task create\n  $ sidecar task create --title "Add import support" --summary "Support JSON import" --goal "Enable scripted import flow" --priority high\n  $ sidecar task create --title "Refactor parser" --files-read src/parser.ts,src/types.ts --dod "Tests pass,Docs updated"')
+    .addHelpText('after', '\nExamples:\n' +
+    '  $ sidecar task create --title "Ship docs update" --summary "Update README hero"\n' +
+    '      --trigger "When >=6 hubs are published" --trigger-check "node scripts/check-hubs.mjs --min 6"\n' +
+    '      --entry-points README.md,POSITIONING.md --done-condition "README hero matches retrieval positioning"\n' +
+    '      --validate-cmd "npm run build"\n' +
+    '  $ sidecar task create --title "Follow-up patch" --summary "Apply merged run feedback"\n' +
+    '      --trigger "After T-012 is done" --depends-on T-012 --entry-points src/cli.ts\n' +
+    '      --done-condition "Regression no longer reproduces" --validate-cmd "npm test"')
     .action(async (opts) => {
     const command = 'task create';
     try {
         const rootPath = resolveProjectRoot();
         let title = opts.title?.trim() ?? '';
         let summary = opts.summary?.trim() ?? '';
-        let goal = opts.goal?.trim() ?? '';
-        if (!title || !summary || !goal) {
+        let triggerCondition = opts.trigger?.trim() ?? '';
+        let entryPointsRaw = opts.entryPoints?.trim() ?? '';
+        let doneCondition = opts.doneCondition?.trim() ?? '';
+        let validationCommand = opts.validateCmd?.trim() ?? '';
+        if (!title || !summary || !triggerCondition || !entryPointsRaw || !doneCondition || !validationCommand) {
             if (!process.stdin.isTTY) {
-                fail('Missing required fields. Provide --title, --summary, and --goal when not running interactively.');
+                fail('Missing required fields. Provide --title, --summary, --trigger, --entry-points, --done-condition, and --validate-cmd when not running interactively.');
             }
             const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
             try {
                 title = title || (await askWithDefault(rl, 'Title'));
                 summary = summary || (await askWithDefault(rl, 'Summary', title));
-                goal = goal || (await askWithDefault(rl, 'Goal', `Complete: ${title}`));
+                triggerCondition = triggerCondition || (await askWithDefault(rl, 'Trigger condition'));
+                entryPointsRaw = entryPointsRaw || (await askWithDefault(rl, 'Entry points (comma-separated files)'));
+                doneCondition = doneCondition || (await askWithDefault(rl, 'Done condition', `Complete: ${title}`));
+                validationCommand = validationCommand || (await askWithDefault(rl, 'Validation command', 'npm run build'));
             }
             finally {
                 rl.close();
             }
         }
-        const type = taskPacketTypeSchema.parse(opts.type);
         const status = taskPacketStatusSchema.parse(opts.status);
         const priority = taskPacketPrioritySchema.parse(opts.priority);
+        const entryPoints = parseCsvOption(entryPointsRaw);
+        if (entryPoints.length === 0 || entryPoints.length > 3) {
+            fail('Entry points must include between 1 and 3 paths');
+        }
         const created = createTaskPacketRecord(rootPath, {
             title,
             summary,
-            goal,
-            type,
             status,
             priority,
-            scope_in_scope: parseCsvOption(opts.scopeIn),
-            scope_out_of_scope: parseCsvOption(opts.scopeOut),
-            related_decisions: parseCsvOption(opts.relatedDecisions),
-            related_notes: parseCsvOption(opts.relatedNotes),
-            files_to_read: parseCsvOption(opts.filesRead),
-            files_to_avoid: parseCsvOption(opts.filesAvoid),
-            technical_constraints: parseCsvOption(opts.constraintTech),
-            design_constraints: parseCsvOption(opts.constraintDesign),
-            validation_commands: parseCsvOption(opts.validateCmds),
-            dependencies: parseCsvOption(opts.dependencies).map((v) => v.toUpperCase()),
-            tags: parseCsvOption(opts.tags),
-            target_areas: parseCsvOption(opts.targetAreas),
-            definition_of_done: parseCsvOption(opts.dod),
-            branch: opts.branch?.trim(),
-            worktree: opts.worktree?.trim(),
+            trigger_condition: triggerCondition,
+            trigger_check_command: opts.triggerCheck?.trim() || undefined,
+            trigger_depends_on: parseCsvOption(opts.dependsOn).map((v) => v.toUpperCase()),
+            entry_points: entryPoints,
+            done_condition: doneCondition,
+            validation_command: validationCommand,
         });
         respondSuccess(command, Boolean(opts.json), { task: created.task, path: created.path }, [`Created task ${created.task.task_id}.`, `Path: ${created.path}`]);
     }
@@ -1099,9 +1086,9 @@ task
 task
     .command('list')
     .description('List task packets')
-    .option('--status <status>', 'draft|ready|queued|running|review|blocked|done|all', 'all')
+    .option('--status <status>', 'active|blocked|done|all', 'all')
     .option('--json', 'Print machine-readable JSON output')
-    .addHelpText('after', '\nExamples:\n  $ sidecar task list\n  $ sidecar task list --status draft\n  $ sidecar task list --json')
+    .addHelpText('after', '\nExamples:\n  $ sidecar task list\n  $ sidecar task list --status active\n  $ sidecar task list --json')
     .action((opts) => {
     const command = 'task list';
     try {
@@ -1162,12 +1149,12 @@ task
 task
     .command('set-status <task-id>')
     .description('Transition task packet status with validation and an audit note')
-    .requiredOption('--to <status>', 'draft|ready|queued|running|review|blocked|done')
+    .requiredOption('--to <status>', 'active|blocked|done')
     .requiredOption('--reason <text>', 'Why this manual transition is needed')
     .option('--by <actor>', 'human|agent', 'human')
     .option('--session <session-id>', 'Session id override')
     .option('--json', 'Print machine-readable JSON output')
-    .addHelpText('after', '\nExamples:\n  $ sidecar task set-status T-001 --to ready --reason "Ready to queue"\n  $ sidecar task set-status T-001 --to done --reason "Administrative cleanup" --by agent --json')
+    .addHelpText('after', '\nExamples:\n  $ sidecar task set-status T-001 --to active --reason "Trigger is now satisfied"\n  $ sidecar task set-status T-001 --to done --reason "Administrative cleanup" --by agent --json')
     .action((taskIdText, opts) => {
     const command = 'task set-status';
     try {
@@ -1463,7 +1450,7 @@ const run = program
     .addHelpText('after', '\nExamples:\n  $ sidecar run T-001 --dry-run\n  $ sidecar run T-001 --runner claude --agent-role reviewer\n  $ sidecar run replay R-010 --edit-prompt\n  $ sidecar run replay R-010 --runner claude --reason "second opinion"\n  $ sidecar run queue\n  $ sidecar run start-ready --dry-run\n  $ sidecar run list --task T-001\n  $ sidecar run show R-001');
 run
     .command('queue')
-    .description('Queue all ready tasks with satisfied dependencies')
+    .description('Evaluate active tasks and mark dependency-blocked tasks')
     .option('--json', 'Print machine-readable JSON output')
     .addHelpText('after', '\nExamples:\n  $ sidecar run queue\n  $ sidecar run queue --json')
     .action((opts) => {
@@ -1472,7 +1459,7 @@ run
         const rootPath = resolveProjectRoot();
         const decisions = queueReadyTasks(rootPath);
         respondSuccess(command, Boolean(opts.json), { decisions }, [
-            `Processed ${decisions.length} ready task(s).`,
+            `Processed ${decisions.length} active task(s).`,
             ...decisions.map((d) => `- ${d.task_id}: ${d.reason}`),
         ]);
     }
@@ -1482,7 +1469,7 @@ run
 });
 run
     .command('start-ready')
-    .description('Queue and start all runnable ready tasks')
+    .description('Evaluate active tasks and run the ones with satisfied triggers')
     .option('--dry-run', 'Prepare and compile only without executing external runners')
     .option('--json', 'Print machine-readable JSON output')
     .addHelpText('after', '\nExamples:\n  $ sidecar run start-ready\n  $ sidecar run start-ready --dry-run --json')
@@ -1491,9 +1478,13 @@ run
     try {
         const rootPath = resolveProjectRoot();
         const queueDecisions = queueReadyTasks(rootPath);
-        const queuedTasks = listTaskPackets(rootPath).filter((task) => task.status === 'queued');
+        const runnableTasks = queueDecisions
+            .filter((d) => d.queued)
+            .map((d) => d.task_id)
+            .map((taskId) => getTaskPacket(rootPath, taskId))
+            .filter((task) => task.status === 'active');
         const results = [];
-        for (const task of queuedTasks) {
+        for (const task of runnableTasks) {
             const result = await runTaskExecution({
                 rootPath,
                 taskId: task.task_id,

package/dist/prompts/packet-sections.js

@@ -1,14 +1,24 @@
-// Adapter from TaskPacket → CompileSectionsInput. Mirrors the legacy packet
-// layout exactly so `sidecar run <task-id>` produces byte-identical prompts
-// after the compiler refactor. Snapshot-guarded in `prompts.compat.test`.
 import { nowIso } from '../lib/format.js';
 import { PROMPT_PREFERENCE_DEFAULTS } from '../runners/config.js';
+function textSection(id, title, content) {
+    return { id, title, kind: 'text', content, trim: 'keep' };
+}
+function listSection(id, title, items, options) {
+    return {
+        id,
+        title,
+        kind: 'list',
+        items,
+        ...(options?.empty_placeholder ? { empty_placeholder: options.empty_placeholder } : {}),
+        ...(options?.trim ? { trim: options.trim } : { trim: { policy: 'keep' } }),
+    };
+}
 function finalResponseFormat(runner) {
     if (runner === 'codex') {
         return [
             '- Start with a one-line outcome summary.',
             '- List files changed with concise reasons.',
-            '- Include validation commands run and their results.',
+            '- Include validation command output.',
             '- Note risks, blockers, or follow-up tasks.',
         ];
     }
@@ -33,59 +43,32 @@ function runnerGuidance(runner) {
         'Provide a clear summary with validation and follow-up notes at the end.',
     ];
 }
-function textSection(id, title, content) {
-    return { id, title, kind: 'text', content, trim: 'keep' };
-}
-function listSection(id, title, items, options) {
-    return {
-        id,
-        title,
-        kind: 'list',
-        items,
-        ...(options?.empty_placeholder ? { empty_placeholder: options.empty_placeholder } : {}),
-        ...(options?.trim ? { trim: options.trim } : { trim: { policy: 'keep' } }),
-    };
-}
-function validationLine(v) {
-    const label = v.name ? `${v.kind}:${v.name}` : v.kind;
-    return v.kind === 'custom' ? v.command : `${label} — \`${v.command}\``;
-}
-// Linked context uses two sub-lists (decisions + notes) under one heading. The
-// legacy layout merged them so we render as a single `text` section whose
-// content is the pre-formatted bullet list, and trim by hand before handing it
-// to the core. That keeps byte-identical output without teaching the core
-// about multi-list sections.
 function renderLinkedContext(relatedDecisions, relatedNotes, mode) {
     const lines = [];
     const decisions = mode === 'full'
         ? relatedDecisions
         : mode === 'trim'
-            ? sliceWithOverflow(relatedDecisions, 3, 'decisions')
-            : sliceWithOverflow(relatedDecisions, 1, 'decisions');
+            ? relatedDecisions.slice(0, 3)
+            : relatedDecisions.slice(0, 1);
     const notes = mode === 'full'
         ? relatedNotes
         : mode === 'trim'
-            ? sliceWithOverflow(relatedNotes, 2, 'notes')
-            : sliceWithOverflow(relatedNotes, 0, 'notes');
-    if (decisions.length === 0)
-        lines.push('- no related decisions');
-    else
+            ? relatedNotes.slice(0, 2)
+            : [];
+    if (decisions.length > 0) {
+        lines.push('Decisions:');
         for (const d of decisions)
             lines.push(`- ${d}`);
-    if (notes.length === 0)
-        lines.push('- no related notes');
-    else
+    }
+    if (notes.length > 0) {
+        lines.push('Notes:');
         for (const n of notes)
             lines.push(`- ${n}`);
+    }
+    if (lines.length === 0)
+        lines.push('- no linked context');
     return lines;
 }
-function sliceWithOverflow(items, limit, label) {
-    if (items.length <= limit)
-        return items;
-    const kept = items.slice(0, limit);
-    kept.push(`+ ${items.length - limit} more ${label} (see task packet for full list)`);
-    return kept;
-}
 function renderPreviousRuns(runs) {
     const lines = [];
     runs.forEach((prev, idx) => {
@@ -102,34 +85,12 @@ function renderPreviousRuns(runs) {
             lines.push(`- Changed files (${prev.changed_files.length}):`);
             for (const f of limited)
                 lines.push(`  - ${f}`);
-            if (prev.changed_files.length > limited.length) {
-                lines.push(`  - + ${prev.changed_files.length - limited.length} more (see run record)`);
-            }
-        }
-        if (prev.log_tail) {
-            lines.push('- Log tail:');
-            lines.push('```');
-            for (const line of prev.log_tail.split('\n'))
-                lines.push(line);
-            lines.push('```');
+            if (prev.changed_files.length > limited.length)
+                lines.push(`  - + ${prev.changed_files.length - limited.length} more`);
         }
     });
     return lines;
 }
-function renderConstraints(technical, design) {
-    const lines = [];
-    if (technical.length === 0)
-        lines.push('- no technical constraints');
-    else
-        for (const t of technical)
-            lines.push(`- ${t}`);
-    if (design.length === 0)
-        lines.push('- no design constraints');
-    else
-        for (const d of design)
-            lines.push(`- ${d}`);
-    return lines;
-}
 export function packetToCompileInput(input) {
     const { task, run, runner, agentRole, linkedContext, budget } = input;
     const pref = budget ?? PROMPT_PREFERENCE_DEFAULTS;
@@ -142,38 +103,30 @@ export function packetToCompileInput(input) {
         `Task id: ${task.task_id}`,
         `Compiled at: ${nowIso()}`,
     ];
-    const relatedDecisions = linkedContext?.related_decisions ?? task.context.related_decisions;
-    const relatedNotes = linkedContext?.related_notes ?? task.context.related_notes;
+    const relatedDecisions = linkedContext?.related_decisions ?? [];
+    const relatedNotes = linkedContext?.related_notes ?? [];
     const sections = [
         textSection('task', 'Task', [
             `- ${task.title}`,
-            `- Type: ${task.type}`,
             `- Priority: ${task.priority}`,
             `- Status: ${task.status}`,
+            `- Created: ${task.created_at}`,
         ]),
-        textSection('objective', 'Objective', [task.goal]),
-        textSection('why', 'Why this matters', [task.summary]),
-        listSection('in_scope', 'In scope', task.scope.in_scope, {
-            trim: { policy: 'trim-last', limit: 8, limit_strict: 8, overflow_label: 'in-scope items' },
-        }),
-        listSection('out_of_scope', 'Out of scope', task.scope.out_of_scope, {
-            trim: { policy: 'trim-last', limit: 5, limit_strict: 3, overflow_label: 'out-of-scope items' },
-        }),
-        listSection('files_to_read', 'Read these first', task.implementation.files_to_read, {
-            trim: { policy: 'trim-last', limit: 10, limit_strict: 10, overflow_label: 'read-first files' },
-        }),
-        listSection('files_to_avoid', 'Avoid changing', task.implementation.files_to_avoid, {
-            trim: { policy: 'trim-last', limit: 5, limit_strict: 3, overflow_label: 'avoid files' },
+        textSection('objective', 'Objective', [task.summary]),
+        textSection('trigger', 'Trigger', [
+            `- Condition: ${task.trigger.condition}`,
+            ...(task.trigger.check_command ? [`- Verify: \`${task.trigger.check_command}\``] : []),
+            ...(task.trigger.depends_on.length > 0 ? [`- Depends on: ${task.trigger.depends_on.join(', ')}`] : []),
+        ]),
+        listSection('entry_points', 'Entry points', task.entry_points, {
+            trim: { policy: 'trim-last', limit: 3, limit_strict: 3, overflow_label: 'entry points' },
         }),
-        // Linked context stays a text section so the "no related X" placeholders stay where they were.
+        textSection('definition_of_done', 'Definition of done', [task.done_condition]),
+        textSection('validation', 'Validation command', [`\`${task.validation_command}\``]),
         textSection('linked_context', 'Linked context', renderLinkedContext(relatedDecisions, relatedNotes, 'full')),
-        // Previous runner context — only when this run is a later step in a pipeline.
         ...(linkedContext?.previous_runs && linkedContext.previous_runs.length > 0
             ? [textSection('previous_runs', 'Previous runner context', renderPreviousRuns(linkedContext.previous_runs))]
             : []),
-        textSection('constraints', 'Constraints', renderConstraints(task.constraints.technical, task.constraints.design)),
-        listSection('validation', 'Validation', task.execution.commands.validation.map(validationLine)),
-        listSection('definition_of_done', 'Definition of done', task.definition_of_done),
         textSection('runner_guidance', 'Runner guidance', runnerGuidance(runner)),
         textSection('final_response_format', 'Final response format', finalResponseFormat(runner)),
     ];
@@ -183,21 +136,6 @@ export function packetToCompileInput(input) {
         budget: { target: pref.budget_target, max: pref.budget_max },
     };
 }
-// Legacy metadata expects `trimmed_sections: string[]` using the historical names.
-// Map the new core metadata back for back-compat.
-export const LEGACY_TRIM_IDS = [
-    'in_scope',
-    'out_of_scope',
-    'files_to_read',
-    'files_to_avoid',
-    'related_decisions',
-    'related_notes',
-];
-// Rebuild linked_context lines under a trim mode. The core compileSections()
-// can't partially trim a text section, so we run the full pipeline twice in
-// prompt-compiler.ts: first with full linked_context, and again with trimmed
-// linked_context if the baseline is over budget. See prompt-compiler.ts for
-// the wrapper that orchestrates this.
 export function linkedContextForMode(relatedDecisions, relatedNotes, mode) {
     return renderLinkedContext(relatedDecisions, relatedNotes, mode);
 }

package/dist/prompts/prompt-compiler.js

@@ -12,8 +12,8 @@ function packetInputForMode(adapterInput, mode) {
     const baseline = packetToCompileInput(adapterInput);
     if (mode === 'full')
         return baseline;
-    const relatedDecisions = adapterInput.linkedContext?.related_decisions ?? adapterInput.task.context.related_decisions;
-    const relatedNotes = adapterInput.linkedContext?.related_notes ?? adapterInput.task.context.related_notes;
+    const relatedDecisions = adapterInput.linkedContext?.related_decisions ?? [];
+    const relatedNotes = adapterInput.linkedContext?.related_notes ?? [];
     const linkedLines = linkedContextForMode(relatedDecisions, relatedNotes, mode);
     const sections = baseline.sections.map((section) => {
         if (section.id !== 'linked_context')
@@ -27,8 +27,8 @@ function packetInputForMode(adapterInput, mode) {
 function buildLegacyTrimmed(adapterInput, listTrimmed, mode) {
     const out = new Set(listTrimmed);
     if (mode !== 'full') {
-        const decisions = adapterInput.linkedContext?.related_decisions ?? adapterInput.task.context.related_decisions;
-        const notes = adapterInput.linkedContext?.related_notes ?? adapterInput.task.context.related_notes;
+        const decisions = adapterInput.linkedContext?.related_decisions ?? [];
+        const notes = adapterInput.linkedContext?.related_notes ?? [];
         if (mode === 'trim') {
             if (decisions.length > 3)
                 out.add('related_decisions');

package/dist/prompts/prompt-service.js

@@ -9,8 +9,8 @@ export function compileTaskPrompt(input) {
         runner_type: input.runner,
         agent_role: input.agentRole,
         status: 'preparing',
-        branch: task.tracking.branch,
-        worktree: task.tracking.worktree,
+        branch: '',
+        worktree: '',
         ...(input.parentRunId ? { parent_run_id: input.parentRunId } : {}),
         ...(input.replayReason ? { replay_reason: input.replayReason } : {}),
         ...(input.pipelineId ? { pipeline_id: input.pipelineId } : {}),

package/dist/services/capabilities-service.js

@@ -173,31 +173,20 @@ export function getCapabilitiesManifest(version) {
                 subcommands: [
                     {
                         name: 'create',
-                        description: 'Create a structured task packet',
+                        description: 'Create an agent-ready queue task',
                         json_output: true,
                         arguments: [],
                         options: [
                             '--title <title>',
                             '--summary <summary>',
-                            '--goal <goal>',
-                            '--type feature|bug|chore|research',
-                            '--status draft|ready|queued|running|review|blocked|done',
+                            '--status active|blocked|done',
                             '--priority low|medium|high',
-                            '--dependencies <task-ids>',
-                            '--tags <tags>',
-                            '--target-areas <areas>',
-                            '--scope-in <items>',
-                            '--scope-out <items>',
-                            '--related-decisions <items>',
-                            '--related-notes <items>',
-                            '--files-read <paths>',
-                            '--files-avoid <paths>',
-                            '--constraint-tech <items>',
-                            '--constraint-design <items>',
-                            '--validate-cmds <commands>',
-                            '--dod <items>',
-                            '--branch <name>',
-                            '--worktree <path>',
+                            '--trigger <condition>',
+                            '--trigger-check <command>',
+                            '--depends-on <task-ids>',
+                            '--entry-points <paths>',
+                            '--done-condition <text>',
+                            '--validate-cmd <command>',
                             '--json',
                         ],
                     },
@@ -213,7 +202,7 @@ export function getCapabilitiesManifest(version) {
                         description: 'List task packets',
                         json_output: true,
                         arguments: [],
-                        options: ['--status draft|ready|queued|running|review|blocked|done|all', '--json'],
+                        options: ['--status active|blocked|done|all', '--json'],
                     },
                     {
                         name: 'assign',
@@ -227,7 +216,7 @@ export function getCapabilitiesManifest(version) {
                         description: 'Transition task packet status with validation',
                         json_output: true,
                         arguments: ['<task-id>'],
-                        options: ['--to draft|ready|queued|running|review|blocked|done', '--reason <text>', '--by human|agent', '--session <id>', '--json'],
+                        options: ['--to active|blocked|done', '--reason <text>', '--by human|agent', '--session <id>', '--json'],
                     },
                     {
                         name: 'create-followup',
@@ -263,14 +252,14 @@ export function getCapabilitiesManifest(version) {
                 subcommands: [
                     {
                         name: 'queue',
-                        description: 'Queue ready tasks with satisfied dependencies',
+                        description: 'Evaluate active tasks and mark dependency-blocked tasks',
                         json_output: true,
                         arguments: [],
                         options: ['--json'],
                     },
                     {
                         name: 'start-ready',
-                        description: 'Queue and start all runnable ready tasks',
+                        description: 'Evaluate active tasks and run the ones with satisfied triggers',
                         json_output: true,
                         arguments: [],
                         options: ['--dry-run', '--json'],