devworkspace 0.0.0-stage → 0.1.0

package/dist/tasks/routing.js

@@ -0,0 +1,206 @@
+/** Single source of truth for routing. The generated Claude skill and docs/routing.md are rendered from this table. */
+export const WORKFLOWS = {
+    QUESTION: {
+        type: 'QUESTION',
+        contextDepth: 5,
+        readOnly: true,
+        trackTask: false,
+        steps: [
+            'Read .devworkspace/context facts relevant to the topic (devworkspace context --topic <area>).',
+            'Use Graphify (if ready) or targeted search to locate the code; read only the files needed.',
+            'Answer with file references. State uncertainty explicitly.',
+        ],
+        verification: 'None. Do not modify files or run tests.',
+        agentSkills: [],
+        ponytail: 'Not used.',
+        knowledgeUpdate: 'Only if you discovered a durable fact that is missing; record it with "devworkspace fact add".',
+    },
+    BUG: {
+        type: 'BUG',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: [
+            'Check git status; protect uncommitted user changes.',
+            'Investigate and reproduce where practical.',
+            'Write a regression test and confirm it fails.',
+            'Fix the cause, confirm the test passes.',
+            'Run the applicable regression suite, then typecheck/lint/build as required by the testing contract.',
+            'Review the diff; record results with "devworkspace task verify".',
+        ],
+        verification: 'Regression test, applicable suite, typecheck, lint, build (whatever the testing contract marks required).',
+        agentSkills: ['/test', '/review'],
+        ponytail: 'Light review of the diff when review level is not "off".',
+        knowledgeUpdate: 'Only if the bug revealed a persistent constraint or convention.',
+    },
+    FEATURE: {
+        type: 'FEATURE',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: [
+            'Check git status. Read relevant facts and decisions.',
+            'Write acceptance criteria and a short plan (task update).',
+            'Write tests for the criteria, then implement.',
+            'Run targeted tests, then regression, then typecheck/lint/build.',
+            'Review the diff.',
+            'Update project knowledge for architecture, conventions or decisions that changed.',
+        ],
+        verification: 'Targeted tests, regression, typecheck, lint, build, review.',
+        agentSkills: ['/spec', '/plan', '/build', '/test', '/review'],
+        ponytail: 'Review for unnecessary complexity before completion.',
+        knowledgeUpdate: 'Yes when the feature adds a module, integration, business rule or decision.',
+    },
+    REFACTOR: {
+        type: 'REFACTOR',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: [
+            'Check git status. Analyse architecture, decisions and dependents (Graphify).',
+            'Record a baseline test result (devworkspace task tests --phase baseline).',
+            'Plan, then refactor in small verified steps.',
+            'Run targeted verification and the full regression suite; compare against the baseline.',
+            'Review the diff.',
+        ],
+        verification: 'Baseline vs after (no regressions), typecheck, lint, build, review.',
+        agentSkills: ['/plan', '/code-simplify', '/review'],
+        ponytail: 'Use for simplification review.',
+        knowledgeUpdate: 'Yes if structure or conventions changed.',
+    },
+    DOCUMENTATION: {
+        type: 'DOCUMENTATION',
+        contextDepth: 4,
+        readOnly: false,
+        trackTask: false,
+        steps: ['Read the code or facts being documented.', 'Edit documentation only.', 'Run documentation checks if the project has them (link or lint checks).'],
+        verification: 'Only checks that apply to documentation.',
+        agentSkills: [],
+        ponytail: 'Not used.',
+        knowledgeUpdate: 'Rarely.',
+    },
+    TESTING: {
+        type: 'TESTING',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Check git status.', 'Find existing test conventions.', 'Add tests; confirm they fail for the right reason where applicable.', 'Run the affected suite plus typecheck and lint.'],
+        verification: 'Affected tests, typecheck, lint.',
+        agentSkills: ['/test'],
+        ponytail: 'Optional.',
+        knowledgeUpdate: 'If the testing strategy or commands changed.',
+    },
+    PERFORMANCE: {
+        type: 'PERFORMANCE',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Measure first; record the baseline.', 'Change one thing at a time.', 'Re-measure and run the regression suite and build.', 'Review.'],
+        verification: 'Before/after measurement, regression suite, build.',
+        agentSkills: ['/webperf', '/review'],
+        ponytail: 'Review for added complexity.',
+        knowledgeUpdate: 'If a persistent constraint or decision emerged.',
+    },
+    SECURITY: {
+        type: 'SECURITY',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Check git status.', 'Understand the threat and the affected paths.', 'Test that demonstrates the issue, then fix.', 'Regression suite, typecheck, lint, build.', 'Security-focused review. Never print secret values.'],
+        verification: 'Regression and exploit test, typecheck, lint, build, review.',
+        agentSkills: ['/test', '/review'],
+        ponytail: 'Use for bug and security review of the diff.',
+        knowledgeUpdate: 'Yes for new security conventions or decisions.',
+    },
+    ARCHITECTURE: {
+        type: 'ARCHITECTURE',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Read facts, decisions and architecture notes; map structure with Graphify.', 'Present options and record the chosen one with "devworkspace decision add".', 'Plan and implement in verified steps.', 'Full verification and review.'],
+        verification: 'Baseline vs after, typecheck, lint, build, review.',
+        agentSkills: ['/spec', '/plan', '/build', '/review'],
+        ponytail: 'Review for unnecessary abstraction.',
+        knowledgeUpdate: 'Always: architecture notes and the decision record.',
+    },
+    RELEASE: {
+        type: 'RELEASE',
+        contextDepth: 6,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Check git status and branch.', 'Run the full testing contract including integration/e2e where available.', 'Update changelog and version per project convention.', 'Do not publish or push without explicit user authorisation.'],
+        verification: 'Everything in the testing contract.',
+        agentSkills: ['/ship'],
+        ponytail: 'Optional final review.',
+        knowledgeUpdate: 'If release process facts changed.',
+    },
+    MAINTENANCE: {
+        type: 'MAINTENANCE',
+        contextDepth: 4,
+        readOnly: false,
+        trackTask: true,
+        steps: ['Check git status.', 'Make the change.', 'Run lint and build; run tests when behaviour could change.'],
+        verification: 'Lint, build, tests if behaviour could change.',
+        agentSkills: [],
+        ponytail: 'Optional.',
+        knowledgeUpdate: 'Only for changed commands or tooling.',
+    },
+};
+const OVERRIDE_PATTERNS = [
+    ['no-modify', /\b(?:only|just)\s+(?:explain|describe|investigate|look|read|review)\b|\b(?:do\s*n[o']t|don'?t|never)\s+(?:modify|change|edit|touch)\b|\bread[- ]only\b|\bno\s+changes\b/i],
+    ['plan-only', /\b(?:only|just)\s+(?:make\s+|write\s+|give\s+me\s+)?a\s+plan\b|\bplan\s+only\b/i],
+    ['no-commit', /\b(?:do\s*n[o']t|don'?t|never)\s+commit\b|\bno\s+commits?\b/i],
+    ['no-e2e', /\b(?:do\s*n[o']t|don'?t|skip|no)\s+(?:run\s+)?(?:the\s+)?(?:e2e|end[- ]to[- ]end)\b/i],
+    ['no-tests', /\b(?:do\s*n[o']t|don'?t|skip)\s+(?:run\s+)?(?:any\s+|the\s+)?tests\b(?!\s+but)/i],
+    ['no-fix', /\b(?:do\s*n[o']t|don'?t)\s+fix\b|\bwithout\s+fixing\b/i],
+];
+export function detectConstraints(text) {
+    return OVERRIDE_PATTERNS.filter(([, re]) => re.test(text)).map(([c]) => c);
+}
+const QUESTION_START = /^\s*(?:where|what|which|who|when|how\s+(?:does|do|is|are|can|should)|why|explain|describe|show\s+me|walk\s+me|is\s+there|are\s+there|can\s+you\s+(?:explain|tell|show)|tell\s+me|list|find)\b/i;
+const IMPERATIVE_START = /^\s*(?:fix|add|implement|create|build|refactor|remove|delete|update|change|rename|write|make|migrate|upgrade|optimi[sz]e|release|publish)\b/i;
+/** Heuristic classifier used to propose a task type. The agent may override it; ambiguous input defaults to the safest (read-only) type. */
+export function classifyRequest(text) {
+    const constraints = detectConstraints(text);
+    // Negated phrases ("don't fix anything") describe limits, not the task itself.
+    const t = OVERRIDE_PATTERNS.reduce((acc, [, re]) => acc.replace(new RegExp(re.source, re.flags + 'g'), ' '), text).trim();
+    const make = (type, confidence) => ({
+        type,
+        confidence,
+        constraints,
+        readOnly: WORKFLOWS[type].readOnly || constraints.includes('no-modify') || constraints.includes('plan-only'),
+    });
+    if (QUESTION_START.test(t) && !IMPERATIVE_START.test(t))
+        return make('QUESTION', 'high');
+    if (/\b(?:add|write|improve|increase)\s+(?:\w+\s+)?(?:unit\s+|e2e\s+|integration\s+)?tests?\b|\btest coverage\b|^\s*run\s+(?:the\s+|all\s+)?(?:\w+\s+)?tests?\b/i.test(t))
+        return make('TESTING', 'high');
+    if (/\b(?:upgrade|bump|update\s+dependenc\w*)\b/i.test(t))
+        return make('MAINTENANCE', 'high');
+    if (/\b(?:fix|bug|broken|crash(?:es|ing)?|regression|not working|fails?|failing|exception|error)\b/i.test(t))
+        return make('BUG', 'high');
+    if (/\b(?:refactor|restructure|reorgani[sz]e|clean\s?up|simplify|de-?duplicate)\b/i.test(t))
+        return make('REFACTOR', 'high');
+    if (/\b(?:vulnerab\w*|security|csrf|xss|sql injection|sanitiz\w*|harden\w*|cve-\d+)\b/i.test(t))
+        return make('SECURITY', 'high');
+    if (/\b(?:performance|slow|latency|speed up|optimi[sz]e|throughput)\b/i.test(t))
+        return make('PERFORMANCE', 'high');
+    if (/\b(?:document|readme|docs|changelog|jsdoc|docstring)\b/i.test(t))
+        return make('DOCUMENTATION', 'high');
+    if (/\b(?:release|publish|deploy|ship|version bump)\b/i.test(t))
+        return make('RELEASE', 'high');
+    if (/\b(?:upgrade|bump|update\s+dependenc\w*|chore|lint(?:ing)?|format(?:ting)?)\b/i.test(t))
+        return make('MAINTENANCE', 'high');
+    if (/\b(?:redesign|re-?architect\w*|migrate\s+to|architecture)\b/i.test(t))
+        return make('ARCHITECTURE', 'high');
+    if (/\b(?:add|implement|create|build|support|introduce|enable|new)\b/i.test(t))
+        return make('FEATURE', 'high');
+    return make('QUESTION', 'low');
+}
+export function renderRoutingTable() {
+    const rows = Object.values(WORKFLOWS).map((w) => {
+        const flags = [w.readOnly ? 'read-only' : 'modifies code', w.trackTask ? 'tracked task' : 'no task file'].join(', ');
+        return `| ${w.type} | ${flags} | L${w.contextDepth} | ${w.verification} |`;
+    });
+    return ['| Type | Nature | Max context | Verification |', '| --- | --- | --- | --- |', ...rows].join('\n');
+}
+//# sourceMappingURL=routing.js.map

package/dist/tasks/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../src/tasks/routing.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TaskType } from './task.js';\n\nexport type Constraint = 'no-modify' | 'plan-only' | 'no-commit' | 'no-e2e' | 'no-tests' | 'no-fix';\n\nexport interface WorkflowSpec {\n  type: TaskType;\n  /** Highest context level normally needed (1 instructions … 6 tests/implementation). */\n  contextDepth: 1 | 2 | 3 | 4 | 5 | 6;\n  readOnly: boolean;\n  trackTask: boolean;\n  steps: string[];\n  verification: string;\n  agentSkills: string[];\n  ponytail: string;\n  knowledgeUpdate: string;\n}\n\n/** Single source of truth for routing. The generated Claude skill and docs/routing.md are rendered from this table. */\nexport const WORKFLOWS: Record<TaskType, WorkflowSpec> = {\n  QUESTION: {\n    type: 'QUESTION',\n    contextDepth: 5,\n    readOnly: true,\n    trackTask: false,\n    steps: [\n      'Read .devworkspace/context facts relevant to the topic (devworkspace context --topic <area>).',\n      'Use Graphify (if ready) or targeted search to locate the code; read only the files needed.',\n      'Answer with file references. State uncertainty explicitly.',\n    ],\n    verification: 'None. Do not modify files or run tests.',\n    agentSkills: [],\n    ponytail: 'Not used.',\n    knowledgeUpdate: 'Only if you discovered a durable fact that is missing; record it with \"devworkspace fact add\".',\n  },\n  BUG: {\n    type: 'BUG',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: [\n      'Check git status; protect uncommitted user changes.',\n      'Investigate and reproduce where practical.',\n      'Write a regression test and confirm it fails.',\n      'Fix the cause, confirm the test passes.',\n      'Run the applicable regression suite, then typecheck/lint/build as required by the testing contract.',\n      'Review the diff; record results with \"devworkspace task verify\".',\n    ],\n    verification: 'Regression test, applicable suite, typecheck, lint, build (whatever the testing contract marks required).',\n    agentSkills: ['/test', '/review'],\n    ponytail: 'Light review of the diff when review level is not \"off\".',\n    knowledgeUpdate: 'Only if the bug revealed a persistent constraint or convention.',\n  },\n  FEATURE: {\n    type: 'FEATURE',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: [\n      'Check git status. Read relevant facts and decisions.',\n      'Write acceptance criteria and a short plan (task update).',\n      'Write tests for the criteria, then implement.',\n      'Run targeted tests, then regression, then typecheck/lint/build.',\n      'Review the diff.',\n      'Update project knowledge for architecture, conventions or decisions that changed.',\n    ],\n    verification: 'Targeted tests, regression, typecheck, lint, build, review.',\n    agentSkills: ['/spec', '/plan', '/build', '/test', '/review'],\n    ponytail: 'Review for unnecessary complexity before completion.',\n    knowledgeUpdate: 'Yes when the feature adds a module, integration, business rule or decision.',\n  },\n  REFACTOR: {\n    type: 'REFACTOR',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: [\n      'Check git status. Analyse architecture, decisions and dependents (Graphify).',\n      'Record a baseline test result (devworkspace task tests --phase baseline).',\n      'Plan, then refactor in small verified steps.',\n      'Run targeted verification and the full regression suite; compare against the baseline.',\n      'Review the diff.',\n    ],\n    verification: 'Baseline vs after (no regressions), typecheck, lint, build, review.',\n    agentSkills: ['/plan', '/code-simplify', '/review'],\n    ponytail: 'Use for simplification review.',\n    knowledgeUpdate: 'Yes if structure or conventions changed.',\n  },\n  DOCUMENTATION: {\n    type: 'DOCUMENTATION',\n    contextDepth: 4,\n    readOnly: false,\n    trackTask: false,\n    steps: ['Read the code or facts being documented.', 'Edit documentation only.', 'Run documentation checks if the project has them (link or lint checks).'],\n    verification: 'Only checks that apply to documentation.',\n    agentSkills: [],\n    ponytail: 'Not used.',\n    knowledgeUpdate: 'Rarely.',\n  },\n  TESTING: {\n    type: 'TESTING',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Check git status.', 'Find existing test conventions.', 'Add tests; confirm they fail for the right reason where applicable.', 'Run the affected suite plus typecheck and lint.'],\n    verification: 'Affected tests, typecheck, lint.',\n    agentSkills: ['/test'],\n    ponytail: 'Optional.',\n    knowledgeUpdate: 'If the testing strategy or commands changed.',\n  },\n  PERFORMANCE: {\n    type: 'PERFORMANCE',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Measure first; record the baseline.', 'Change one thing at a time.', 'Re-measure and run the regression suite and build.', 'Review.'],\n    verification: 'Before/after measurement, regression suite, build.',\n    agentSkills: ['/webperf', '/review'],\n    ponytail: 'Review for added complexity.',\n    knowledgeUpdate: 'If a persistent constraint or decision emerged.',\n  },\n  SECURITY: {\n    type: 'SECURITY',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Check git status.', 'Understand the threat and the affected paths.', 'Test that demonstrates the issue, then fix.', 'Regression suite, typecheck, lint, build.', 'Security-focused review. Never print secret values.'],\n    verification: 'Regression and exploit test, typecheck, lint, build, review.',\n    agentSkills: ['/test', '/review'],\n    ponytail: 'Use for bug and security review of the diff.',\n    knowledgeUpdate: 'Yes for new security conventions or decisions.',\n  },\n  ARCHITECTURE: {\n    type: 'ARCHITECTURE',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Read facts, decisions and architecture notes; map structure with Graphify.', 'Present options and record the chosen one with \"devworkspace decision add\".', 'Plan and implement in verified steps.', 'Full verification and review.'],\n    verification: 'Baseline vs after, typecheck, lint, build, review.',\n    agentSkills: ['/spec', '/plan', '/build', '/review'],\n    ponytail: 'Review for unnecessary abstraction.',\n    knowledgeUpdate: 'Always: architecture notes and the decision record.',\n  },\n  RELEASE: {\n    type: 'RELEASE',\n    contextDepth: 6,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Check git status and branch.', 'Run the full testing contract including integration/e2e where available.', 'Update changelog and version per project convention.', 'Do not publish or push without explicit user authorisation.'],\n    verification: 'Everything in the testing contract.',\n    agentSkills: ['/ship'],\n    ponytail: 'Optional final review.',\n    knowledgeUpdate: 'If release process facts changed.',\n  },\n  MAINTENANCE: {\n    type: 'MAINTENANCE',\n    contextDepth: 4,\n    readOnly: false,\n    trackTask: true,\n    steps: ['Check git status.', 'Make the change.', 'Run lint and build; run tests when behaviour could change.'],\n    verification: 'Lint, build, tests if behaviour could change.',\n    agentSkills: [],\n    ponytail: 'Optional.',\n    knowledgeUpdate: 'Only for changed commands or tooling.',\n  },\n};\n\nconst OVERRIDE_PATTERNS: [Constraint, RegExp][] = [\n  ['no-modify', /\\b(?:only|just)\\s+(?:explain|describe|investigate|look|read|review)\\b|\\b(?:do\\s*n[o']t|don'?t|never)\\s+(?:modify|change|edit|touch)\\b|\\bread[- ]only\\b|\\bno\\s+changes\\b/i],\n  ['plan-only', /\\b(?:only|just)\\s+(?:make\\s+|write\\s+|give\\s+me\\s+)?a\\s+plan\\b|\\bplan\\s+only\\b/i],\n  ['no-commit', /\\b(?:do\\s*n[o']t|don'?t|never)\\s+commit\\b|\\bno\\s+commits?\\b/i],\n  ['no-e2e', /\\b(?:do\\s*n[o']t|don'?t|skip|no)\\s+(?:run\\s+)?(?:the\\s+)?(?:e2e|end[- ]to[- ]end)\\b/i],\n  ['no-tests', /\\b(?:do\\s*n[o']t|don'?t|skip)\\s+(?:run\\s+)?(?:any\\s+|the\\s+)?tests\\b(?!\\s+but)/i],\n  ['no-fix', /\\b(?:do\\s*n[o']t|don'?t)\\s+fix\\b|\\bwithout\\s+fixing\\b/i],\n];\n\nexport function detectConstraints(text: string): Constraint[] {\n  return OVERRIDE_PATTERNS.filter(([, re]) => re.test(text)).map(([c]) => c);\n}\n\nexport interface Classification {\n  type: TaskType;\n  confidence: 'high' | 'low';\n  constraints: Constraint[];\n  /** True when the request must not change files (question type, or an explicit user override). */\n  readOnly: boolean;\n}\n\nconst QUESTION_START = /^\\s*(?:where|what|which|who|when|how\\s+(?:does|do|is|are|can|should)|why|explain|describe|show\\s+me|walk\\s+me|is\\s+there|are\\s+there|can\\s+you\\s+(?:explain|tell|show)|tell\\s+me|list|find)\\b/i;\nconst IMPERATIVE_START = /^\\s*(?:fix|add|implement|create|build|refactor|remove|delete|update|change|rename|write|make|migrate|upgrade|optimi[sz]e|release|publish)\\b/i;\n\n/** Heuristic classifier used to propose a task type. The agent may override it; ambiguous input defaults to the safest (read-only) type. */\nexport function classifyRequest(text: string): Classification {\n  const constraints = detectConstraints(text);\n  // Negated phrases (\"don't fix anything\") describe limits, not the task itself.\n  const t = OVERRIDE_PATTERNS.reduce((acc, [, re]) => acc.replace(new RegExp(re.source, re.flags + 'g'), ' '), text).trim();\n  const make = (type: TaskType, confidence: 'high' | 'low'): Classification => ({\n    type,\n    confidence,\n    constraints,\n    readOnly: WORKFLOWS[type].readOnly || constraints.includes('no-modify') || constraints.includes('plan-only'),\n  });\n  if (QUESTION_START.test(t) && !IMPERATIVE_START.test(t)) return make('QUESTION', 'high');\n  if (/\\b(?:add|write|improve|increase)\\s+(?:\\w+\\s+)?(?:unit\\s+|e2e\\s+|integration\\s+)?tests?\\b|\\btest coverage\\b|^\\s*run\\s+(?:the\\s+|all\\s+)?(?:\\w+\\s+)?tests?\\b/i.test(t)) return make('TESTING', 'high');\n  if (/\\b(?:upgrade|bump|update\\s+dependenc\\w*)\\b/i.test(t)) return make('MAINTENANCE', 'high');\n  if (/\\b(?:fix|bug|broken|crash(?:es|ing)?|regression|not working|fails?|failing|exception|error)\\b/i.test(t)) return make('BUG', 'high');\n  if (/\\b(?:refactor|restructure|reorgani[sz]e|clean\\s?up|simplify|de-?duplicate)\\b/i.test(t)) return make('REFACTOR', 'high');\n  if (/\\b(?:vulnerab\\w*|security|csrf|xss|sql injection|sanitiz\\w*|harden\\w*|cve-\\d+)\\b/i.test(t)) return make('SECURITY', 'high');\n  if (/\\b(?:performance|slow|latency|speed up|optimi[sz]e|throughput)\\b/i.test(t)) return make('PERFORMANCE', 'high');\n  if (/\\b(?:document|readme|docs|changelog|jsdoc|docstring)\\b/i.test(t)) return make('DOCUMENTATION', 'high');\n  if (/\\b(?:release|publish|deploy|ship|version bump)\\b/i.test(t)) return make('RELEASE', 'high');\n  if (/\\b(?:upgrade|bump|update\\s+dependenc\\w*|chore|lint(?:ing)?|format(?:ting)?)\\b/i.test(t)) return make('MAINTENANCE', 'high');\n  if (/\\b(?:redesign|re-?architect\\w*|migrate\\s+to|architecture)\\b/i.test(t)) return make('ARCHITECTURE', 'high');\n  if (/\\b(?:add|implement|create|build|support|introduce|enable|new)\\b/i.test(t)) return make('FEATURE', 'high');\n  return make('QUESTION', 'low');\n}\n\nexport function renderRoutingTable(): string {\n  const rows = (Object.values(WORKFLOWS) as WorkflowSpec[]).map((w) => {\n    const flags = [w.readOnly ? 'read-only' : 'modifies code', w.trackTask ? 'tracked task' : 'no task file'].join(', ');\n    return `| ${w.type} | ${flags} | L${w.contextDepth} | ${w.verification} |`;\n  });\n  return ['| Type | Nature | Max context | Verification |', '| --- | --- | --- | --- |', ...rows].join('\\n');\n}\n"]}

package/dist/tasks/task.d.ts

@@ -0,0 +1,90 @@
+import { type CommandEntry } from '../config/schemas.js';
+import { type Ws } from '../core/workspace.js';
+export declare const TASK_TYPES: readonly ["QUESTION", "BUG", "FEATURE", "REFACTOR", "DOCUMENTATION", "TESTING", "PERFORMANCE", "SECURITY", "ARCHITECTURE", "RELEASE", "MAINTENANCE"];
+export type TaskType = (typeof TASK_TYPES)[number];
+export declare const TASK_STATUSES: readonly ["IDEA", "SPECIFIED", "PLANNED", "IN_PROGRESS", "TESTING", "REVIEW", "BLOCKED", "FAILED", "COMPLETED"];
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+export declare const VERIFY_STATUSES: readonly ["PENDING", "PASS", "FAIL", "SKIPPED"];
+export type VerifyStatus = (typeof VERIFY_STATUSES)[number];
+export interface VerificationItem {
+    check: string;
+    required: boolean;
+    status: VerifyStatus;
+    reason?: string;
+    detail?: string;
+    updatedAt?: string;
+}
+export interface TestCounts {
+    passed: number;
+    failed: number;
+}
+export interface Attestations {
+    userWorkIntact: boolean;
+    knowledgeReviewed: boolean;
+    finalStateInspected: boolean;
+}
+export interface Task {
+    schemaVersion: number;
+    id: string;
+    title: string;
+    type: TaskType;
+    status: TaskStatus;
+    createdAt: string;
+    updatedAt: string;
+    description: string;
+    acceptanceCriteria: string[];
+    plan: string[];
+    affectedAreas: string[];
+    verification: VerificationItem[];
+    tests: {
+        baseline?: TestCounts;
+        after?: TestCounts;
+    };
+    attestations: Attestations;
+    decisions: string[];
+    blockers: string[];
+    constraints: string[];
+    completionSummary?: string;
+    history: {
+        at: string;
+        from: TaskStatus | null;
+        to: TaskStatus;
+        note?: string;
+    }[];
+}
+export declare function allowedTransitions(from: TaskStatus): TaskStatus[];
+export declare function isCodeChanging(type: TaskType): boolean;
+/** Verification a task of this type needs, given what the project actually offers. Unavailable checks are never demanded. */
+export declare function requiredChecksFor(type: TaskType, contract: CommandEntry[], reviewLevel?: 'off' | 'light' | 'strict'): VerificationItem[];
+export declare function newTaskId(now?: Date): string;
+export interface NewTaskInput {
+    title: string;
+    type: TaskType;
+    description?: string;
+    verification: VerificationItem[];
+    constraints?: string[];
+}
+export declare function createTaskObject(input: NewTaskInput, now: string, id?: string): Task;
+export declare function assertNoSecrets(task: Task): void;
+export declare function validateTask(v: unknown, file?: string): Task;
+export interface GateResult {
+    ok: boolean;
+    failures: string[];
+    warnings: string[];
+}
+/** The completion gate. A task is only COMPLETED when every applicable requirement holds. */
+export declare function evaluateGate(task: Task): GateResult;
+export declare function transitionTask(task: Task, to: TaskStatus, now: string, note?: string): GateResult | null;
+export declare function nextRequiredStep(task: Task): string;
+export declare function saveTask(ws: Ws, task: Task): Promise<void>;
+export declare function loadTask(ws: Ws, idOrPrefix: string): Promise<Task>;
+export interface TaskListing {
+    tasks: Task[];
+    corrupt: {
+        file: string;
+        error: string;
+    }[];
+}
+export declare function listTasks(ws: Ws, opts?: {
+    includeCompleted?: boolean;
+}): Promise<TaskListing>;

package/dist/tasks/task.js

@@ -0,0 +1,275 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { DevWorkspaceError } from '../errors/index.js';
+import { Check } from '../config/validate.js';
+import { SCHEMA_VERSION } from '../config/schemas.js';
+import { atomicWriteJson, ensureDir, pathExists, randomId } from '../utils/fs.js';
+import { readVersioned } from '../core/versioned.js';
+import { backupIfVersionChanges } from '../core/workspace.js';
+import { containsSecret } from '../security/redact.js';
+export const TASK_TYPES = [
+    'QUESTION',
+    'BUG',
+    'FEATURE',
+    'REFACTOR',
+    'DOCUMENTATION',
+    'TESTING',
+    'PERFORMANCE',
+    'SECURITY',
+    'ARCHITECTURE',
+    'RELEASE',
+    'MAINTENANCE',
+];
+export const TASK_STATUSES = ['IDEA', 'SPECIFIED', 'PLANNED', 'IN_PROGRESS', 'TESTING', 'REVIEW', 'BLOCKED', 'FAILED', 'COMPLETED'];
+export const VERIFY_STATUSES = ['PENDING', 'PASS', 'FAIL', 'SKIPPED'];
+const TRANSITIONS = {
+    IDEA: ['SPECIFIED', 'PLANNED', 'IN_PROGRESS', 'BLOCKED', 'FAILED'],
+    SPECIFIED: ['PLANNED', 'IN_PROGRESS', 'BLOCKED', 'IDEA'],
+    PLANNED: ['IN_PROGRESS', 'SPECIFIED', 'BLOCKED', 'IDEA'],
+    IN_PROGRESS: ['TESTING', 'REVIEW', 'COMPLETED', 'BLOCKED', 'FAILED', 'PLANNED'],
+    TESTING: ['IN_PROGRESS', 'REVIEW', 'COMPLETED', 'BLOCKED', 'FAILED'],
+    REVIEW: ['IN_PROGRESS', 'TESTING', 'COMPLETED', 'BLOCKED', 'FAILED'],
+    BLOCKED: ['IN_PROGRESS', 'PLANNED', 'SPECIFIED', 'IDEA', 'FAILED'],
+    FAILED: ['IN_PROGRESS', 'IDEA'],
+    COMPLETED: ['IN_PROGRESS'],
+};
+export function allowedTransitions(from) {
+    return TRANSITIONS[from];
+}
+const CODE_CHANGING = ['BUG', 'FEATURE', 'REFACTOR', 'PERFORMANCE', 'SECURITY', 'ARCHITECTURE', 'MAINTENANCE', 'TESTING', 'RELEASE'];
+const CHECKS_BY_TYPE = {
+    QUESTION: [],
+    DOCUMENTATION: [],
+    BUG: ['unit', 'typecheck', 'lint', 'build'],
+    FEATURE: ['unit', 'typecheck', 'lint', 'build', 'review'],
+    REFACTOR: ['unit', 'typecheck', 'lint', 'build', 'review'],
+    TESTING: ['unit', 'typecheck', 'lint'],
+    PERFORMANCE: ['unit', 'build', 'review'],
+    SECURITY: ['unit', 'typecheck', 'lint', 'build', 'review'],
+    ARCHITECTURE: ['unit', 'typecheck', 'lint', 'build', 'review'],
+    RELEASE: ['unit', 'typecheck', 'lint', 'build', 'integration', 'e2e'],
+    MAINTENANCE: ['lint', 'build'],
+};
+export function isCodeChanging(type) {
+    return CODE_CHANGING.includes(type);
+}
+/** Verification a task of this type needs, given what the project actually offers. Unavailable checks are never demanded. */
+export function requiredChecksFor(type, contract, reviewLevel = 'light') {
+    const available = new Set(contract.filter((c) => c.available).map((c) => c.id));
+    const items = [];
+    for (const check of CHECKS_BY_TYPE[type]) {
+        if (check === 'review') {
+            if (reviewLevel === 'off')
+                continue;
+        }
+        else if (!available.has(check))
+            continue;
+        items.push({ check, required: true, status: 'PENDING' });
+    }
+    return items;
+}
+export function newTaskId(now = new Date()) {
+    const d = now.toISOString().slice(0, 10).replace(/-/g, '');
+    return `T-${d}-${randomId(2)}`;
+}
+export function createTaskObject(input, now, id = newTaskId()) {
+    const title = input.title.trim().slice(0, 200);
+    if (!title)
+        throw new DevWorkspaceError('USAGE', 'Task title must not be empty.');
+    const task = {
+        schemaVersion: SCHEMA_VERSION,
+        id,
+        title,
+        type: input.type,
+        status: 'IDEA',
+        createdAt: now,
+        updatedAt: now,
+        description: (input.description ?? '').trim().slice(0, 4000),
+        acceptanceCriteria: [],
+        plan: [],
+        affectedAreas: [],
+        verification: input.verification,
+        tests: {},
+        attestations: { userWorkIntact: false, knowledgeReviewed: false, finalStateInspected: false },
+        decisions: [],
+        blockers: [],
+        constraints: input.constraints ?? [],
+        history: [{ at: now, from: null, to: 'IDEA' }],
+    };
+    assertNoSecrets(task);
+    return task;
+}
+export function assertNoSecrets(task) {
+    if (containsSecret(JSON.stringify(task))) {
+        throw new DevWorkspaceError('SECURITY', 'Task content looks like it contains a secret; refusing to store it.', {
+            hint: 'Remove credential values from titles, plans and notes.',
+        });
+    }
+}
+export function validateTask(v, file = 'task') {
+    const c = new Check(file);
+    const o = c.obj(v);
+    c.at_('schemaVersion').int(o.schemaVersion, 1);
+    c.at_('id').str(o.id, { min: 3, max: 64 });
+    c.at_('title').str(o.title, { min: 1, max: 300 });
+    c.at_('type').oneOf(o.type, TASK_TYPES);
+    c.at_('status').oneOf(o.status, TASK_STATUSES);
+    c.at_('createdAt').iso(o.createdAt);
+    c.at_('updatedAt').iso(o.updatedAt);
+    for (const k of ['acceptanceCriteria', 'plan', 'affectedAreas', 'decisions', 'blockers', 'constraints'])
+        c.at_(k).strArr(o[k]);
+    c.at_('verification')
+        .arr(o.verification, 100)
+        .forEach((item, i) => {
+        const ic = c.at_(`verification.${i}`);
+        const io = ic.obj(item);
+        ic.at_('check').str(io.check, { max: 50 });
+        ic.at_('required').bool(io.required);
+        ic.at_('status').oneOf(io.status, VERIFY_STATUSES);
+    });
+    const a = c.at_('attestations').obj(o.attestations);
+    c.at_('attestations.userWorkIntact').bool(a.userWorkIntact);
+    c.at_('attestations.knowledgeReviewed').bool(a.knowledgeReviewed);
+    c.at_('attestations.finalStateInspected').bool(a.finalStateInspected);
+    c.at_('tests').obj(o.tests);
+    c.at_('history').arr(o.history, 500);
+    return o;
+}
+/** The completion gate. A task is only COMPLETED when every applicable requirement holds. */
+export function evaluateGate(task) {
+    const failures = [];
+    const warnings = [];
+    for (const v of task.verification) {
+        if (!v.required)
+            continue;
+        if (v.status === 'FAIL')
+            failures.push(`${v.check}: FAIL`);
+        else if (v.status === 'PENDING')
+            failures.push(`${v.check}: not run yet`);
+        else if (v.status === 'SKIPPED') {
+            if (v.reason === 'user-override')
+                warnings.push(`${v.check}: skipped at the user's request; completion is less certain`);
+            else
+                failures.push(`${v.check}: skipped without a user override`);
+        }
+    }
+    const { baseline, after } = task.tests;
+    if (baseline && !after)
+        failures.push('baseline test results recorded, but no results after the change');
+    if (baseline && after) {
+        if (after.failed > baseline.failed)
+            failures.push(`regression: failures rose from ${baseline.failed} to ${after.failed}`);
+        if (after.passed < baseline.passed)
+            failures.push(`regression: passing tests fell from ${baseline.passed} to ${after.passed}`);
+    }
+    if (isCodeChanging(task.type)) {
+        if (!task.attestations.userWorkIntact)
+            failures.push('not confirmed: no user work was overwritten');
+        if (!task.attestations.knowledgeReviewed)
+            failures.push('not confirmed: project knowledge was reviewed for updates');
+        if (!task.attestations.finalStateInspected)
+            failures.push('not confirmed: final repository state was inspected');
+    }
+    if ((isCodeChanging(task.type) || task.type === 'DOCUMENTATION') && !(task.completionSummary ?? '').trim()) {
+        failures.push('completion summary is missing');
+    }
+    return { ok: failures.length === 0, failures, warnings };
+}
+export function transitionTask(task, to, now, note) {
+    if (task.status === to)
+        return null;
+    if (!TRANSITIONS[task.status].includes(to)) {
+        throw new DevWorkspaceError('GATE', `Cannot move a task from ${task.status} to ${to}.`, {
+            hint: `Allowed from ${task.status}: ${TRANSITIONS[task.status].join(', ')}.`,
+        });
+    }
+    let gate = null;
+    if (to === 'COMPLETED') {
+        gate = evaluateGate(task);
+        if (!gate.ok) {
+            throw new DevWorkspaceError('GATE', `Task ${task.id} cannot be completed:\n  - ${gate.failures.join('\n  - ')}`, {
+                hint: 'Resolve the items above (or mark the task BLOCKED/FAILED). A task is never complete while verification is failing.',
+            });
+        }
+    }
+    task.history.push({ at: now, from: task.status, to, ...(note ? { note: note.slice(0, 300) } : {}) });
+    task.status = to;
+    task.updatedAt = now;
+    return gate;
+}
+export function nextRequiredStep(task) {
+    switch (task.status) {
+        case 'COMPLETED':
+            return 'None. The task is complete.';
+        case 'FAILED':
+            return 'Review the failure, then move the task back to IN_PROGRESS or close the idea.';
+        case 'BLOCKED':
+            return task.blockers.length > 0 ? `Resolve blocker: ${task.blockers[task.blockers.length - 1]}` : 'Identify and record what blocks this task.';
+        case 'IDEA':
+            return 'Clarify acceptance criteria, then plan.';
+        case 'SPECIFIED':
+            return 'Write a plan.';
+        case 'PLANNED':
+            return 'Start implementation (baseline verification first for meaningful changes).';
+        default: {
+            const pending = task.verification.filter((v) => v.required && (v.status === 'PENDING' || v.status === 'FAIL'));
+            if (pending.length > 0)
+                return `Run/fix verification: ${pending.map((p) => `${p.check} (${p.status.toLowerCase()})`).join(', ')}.`;
+            const g = evaluateGate(task);
+            return g.ok ? 'All gates pass. Mark the task COMPLETED.' : `Satisfy the completion gate: ${g.failures[0]}`;
+        }
+    }
+}
+// ---------- storage ----------
+function taskFile(ws, task) {
+    return path.join(task.status === 'COMPLETED' ? ws.tasksCompleted : ws.tasksActive, `${task.id}.json`);
+}
+export async function saveTask(ws, task) {
+    validateTask(task);
+    assertNoSecrets(task);
+    const dest = taskFile(ws, task);
+    await backupIfVersionChanges(ws, dest, task.schemaVersion);
+    await ensureDir(path.dirname(dest));
+    await atomicWriteJson(dest, task);
+    const other = path.join(task.status === 'COMPLETED' ? ws.tasksActive : ws.tasksCompleted, `${task.id}.json`);
+    await fs.rm(other, { force: true });
+}
+export async function loadTask(ws, idOrPrefix) {
+    for (const dir of [ws.tasksActive, ws.tasksCompleted]) {
+        if (!(await pathExists(dir)))
+            continue;
+        const names = (await fs.readdir(dir)).filter((n) => n.endsWith('.json'));
+        const hits = names.filter((n) => n === `${idOrPrefix}.json` || n.startsWith(idOrPrefix));
+        if (hits.length > 1) {
+            const exact = hits.find((n) => n === `${idOrPrefix}.json`);
+            if (!exact)
+                throw new DevWorkspaceError('USAGE', `Task id "${idOrPrefix}" is ambiguous.`, { hint: 'Use more characters of the id.' });
+            hits.splice(0, hits.length, exact);
+        }
+        if (hits.length === 1) {
+            const file = path.join(dir, hits[0]);
+            return (await readVersioned(file, 'task', SCHEMA_VERSION, validateTask)).data;
+        }
+    }
+    throw new DevWorkspaceError('NOT_FOUND', `No task matching "${idOrPrefix}".`, { hint: 'List tasks with "devworkspace task list --all".' });
+}
+export async function listTasks(ws, opts = {}) {
+    const tasks = [];
+    const corrupt = [];
+    const dirs = opts.includeCompleted ? [ws.tasksActive, ws.tasksCompleted] : [ws.tasksActive];
+    for (const dir of dirs) {
+        if (!(await pathExists(dir)))
+            continue;
+        for (const name of (await fs.readdir(dir)).filter((n) => n.endsWith('.json')).sort()) {
+            try {
+                tasks.push((await readVersioned(path.join(dir, name), 'task', SCHEMA_VERSION, validateTask)).data);
+            }
+            catch (e) {
+                corrupt.push({ file: `${path.basename(dir)}/${name}`, error: e.message });
+            }
+        }
+    }
+    tasks.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return { tasks, corrupt };
+}
+//# sourceMappingURL=task.js.map