aw-ecc 1.4.32 → 1.4.47

package/.cursor/skills/aw-execute/references/worker-spec-reviewer.md

@@ -1,23 +0,0 @@
-# Worker Role: Spec Reviewer
-
-## Objective
-
-Check one completed task unit against the approved AW inputs before the stage can move forward.
-
-## Inputs
-
-- approved feature inputs from `.aw_docs/features/<feature_slug>/`
-- implementer handoff notes
-- current task-unit bundle
-
-## Required Behavior
-
-1. compare the implementation against the approved task-unit goal
-2. flag scope drift or missed acceptance criteria
-3. state `pass`, `pass_with_notes`, or `fail`
-4. hand back the smallest concrete repair scope when failing
-
-## Hard Gates
-
-- do not invent new product scope
-- do not approve a task unit that skipped a required acceptance point

package/.cursor/skills/aw-execute/scripts/build-worker-bundle.js

@@ -1,229 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function usage() {
-  console.error(
-    'Usage: node skills/aw-execute/scripts/build-worker-bundle.js --feature <slug> --tasks-file <path> [--output <path>] [--allow-parallel] [--max-parallel-workers <n>]'
-  );
-}
-
-function parseArgs(argv) {
-  const args = {
-    allowParallel: false,
-    maxParallelWorkers: 3,
-  };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const current = argv[index];
-    if (current === '--allow-parallel') {
-      args.allowParallel = true;
-      continue;
-    }
-
-    if (!current.startsWith('--')) {
-      throw new Error(`Unexpected argument: ${current}`);
-    }
-
-    const next = argv[index + 1];
-    if (!next || next.startsWith('--')) {
-      throw new Error(`Missing value for ${current}`);
-    }
-
-    if (current === '--feature') {
-      args.featureSlug = next;
-    } else if (current === '--tasks-file') {
-      args.tasksFile = next;
-    } else if (current === '--output') {
-      args.output = next;
-    } else if (current === '--max-parallel-workers') {
-      const parsedValue = Number(next);
-      if (!Number.isInteger(parsedValue) || parsedValue < 1) {
-        throw new Error('--max-parallel-workers must be a positive integer');
-      }
-      args.maxParallelWorkers = parsedValue;
-    } else {
-      throw new Error(`Unknown argument: ${current}`);
-    }
-
-    index += 1;
-  }
-
-  if (!args.featureSlug || !args.tasksFile) {
-    usage();
-    throw new Error('--feature and --tasks-file are required');
-  }
-
-  return args;
-}
-
-function toPosixPath(value) {
-  return value.split(path.sep).join('/');
-}
-
-function parseTaskUnits(content) {
-  const units = [];
-
-  for (const line of content.split(/\r?\n/)) {
-    const match = line.match(/^\s*(?:- \[[ xX]\]|-|\*|\d+\.)\s+(.+?)\s*$/);
-    if (!match) {
-      continue;
-    }
-
-    const title = match[1].trim();
-    if (!title) {
-      continue;
-    }
-
-    units.push(title);
-  }
-
-  if (units.length === 0) {
-    throw new Error('No task units found in tasks file');
-  }
-
-  return units;
-}
-
-function buildRolePrompt({ roleGuide, featureSlug, taskUnitTitle, tasksFilePath, roleName }) {
-  return [
-    `Load role guide: ${roleGuide}`,
-    `Feature slug: ${featureSlug}`,
-    `Task unit: ${taskUnitTitle}`,
-    `Approved task source: ${tasksFilePath}`,
-    `Role: ${roleName}`,
-    'Stay within the repo-local AW execute contract and keep the scope bounded.',
-  ].join('\n');
-}
-
-function buildBundle({ featureSlug, tasksFilePath, allowParallel, maxParallelWorkers, repoRoot }) {
-  const taskUnits = parseTaskUnits(fs.readFileSync(tasksFilePath, 'utf8'));
-  const referencePaths = {
-    implementer: 'skills/aw-execute/references/worker-implementer.md',
-    spec_reviewer: 'skills/aw-execute/references/worker-spec-reviewer.md',
-    quality_reviewer: 'skills/aw-execute/references/worker-quality-reviewer.md',
-    parallel_worker: 'skills/aw-execute/references/worker-parallel-worker.md',
-  };
-
-  const relativeTasksFile = toPosixPath(path.relative(repoRoot, tasksFilePath) || path.basename(tasksFilePath));
-  const bundle = {
-    schema_version: 'aw.execute.worker-bundle.v1',
-    feature_slug: featureSlug,
-    generated_at: new Date().toISOString(),
-    source_tasks_file: relativeTasksFile,
-    role_reference_paths: referencePaths,
-    task_units: taskUnits.map((title, index) => {
-      const taskUnitId = `task-${index + 1}`;
-      const parallelCandidate = allowParallel && taskUnits.length > 1;
-
-      const taskUnit = {
-        id: taskUnitId,
-        title,
-        parallel_candidate: parallelCandidate,
-        roles: {
-          implementer: {
-            reference_path: referencePaths.implementer,
-            prompt: buildRolePrompt({
-              roleGuide: referencePaths.implementer,
-              featureSlug,
-              taskUnitTitle: title,
-              tasksFilePath: relativeTasksFile,
-              roleName: 'implementer',
-            }),
-          },
-          spec_reviewer: {
-            reference_path: referencePaths.spec_reviewer,
-            prompt: buildRolePrompt({
-              roleGuide: referencePaths.spec_reviewer,
-              featureSlug,
-              taskUnitTitle: title,
-              tasksFilePath: relativeTasksFile,
-              roleName: 'spec_reviewer',
-            }),
-          },
-          quality_reviewer: {
-            reference_path: referencePaths.quality_reviewer,
-            prompt: buildRolePrompt({
-              roleGuide: referencePaths.quality_reviewer,
-              featureSlug,
-              taskUnitTitle: title,
-              tasksFilePath: relativeTasksFile,
-              roleName: 'quality_reviewer',
-            }),
-          },
-        },
-      };
-
-      if (parallelCandidate) {
-        taskUnit.roles.parallel_worker = {
-          reference_path: referencePaths.parallel_worker,
-          prompt: buildRolePrompt({
-            roleGuide: referencePaths.parallel_worker,
-            featureSlug,
-            taskUnitTitle: title,
-            tasksFilePath: relativeTasksFile,
-            roleName: 'parallel_worker',
-          }),
-        };
-      }
-
-      return taskUnit;
-    }),
-    orchestration_plan: allowParallel
-      ? {
-          sessionName: `aw-execute-${featureSlug}`,
-          repoRoot,
-          baseRef: 'HEAD',
-          max_parallel_workers: maxParallelWorkers,
-          seedPaths: [
-            'skills/aw-execute/scripts/build-worker-bundle.js',
-            ...Object.values(referencePaths),
-          ],
-          launcherCommand: 'codex exec --skip-git-repo-check "$(cat {task_file_sh})"',
-          workers: taskUnits.map((title, index) => ({
-            name: `implementer-task-${index + 1}`,
-            task: buildRolePrompt({
-              roleGuide: referencePaths.parallel_worker,
-              featureSlug,
-              taskUnitTitle: title,
-              tasksFilePath: relativeTasksFile,
-              roleName: 'parallel_worker',
-            }),
-          })),
-        }
-      : null,
-  };
-
-  return bundle;
-}
-
-function main() {
-  try {
-    const args = parseArgs(process.argv.slice(2));
-    const repoRoot = process.cwd();
-    const tasksFilePath = path.resolve(repoRoot, args.tasksFile);
-    const outputPath = args.output ? path.resolve(repoRoot, args.output) : null;
-    const bundle = buildBundle({
-      featureSlug: args.featureSlug,
-      tasksFilePath,
-      allowParallel: args.allowParallel,
-      maxParallelWorkers: args.maxParallelWorkers,
-      repoRoot,
-    });
-
-    const payload = `${JSON.stringify(bundle, null, 2)}\n`;
-    if (outputPath) {
-      fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-      fs.writeFileSync(outputPath, payload, 'utf8');
-    } else {
-      process.stdout.write(payload);
-    }
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-
-main();

package/.cursor/skills/aw-finish/SKILL.md

@@ -1,111 +0,0 @@
----
-name: aw-finish
-description: Internal compatibility helper for completing a verified development branch with explicit merge, PR, keep, or discard choices and safe worktree cleanup.
-trigger: Internal only. Invoked when verified branch work is done and the next step is a branch-completion decision rather than a staging deployment.
----
-
-# AW Finish
-
-`aw-finish` is a legacy compatibility skill.
-The canonical public release stage remains `/aw:deploy`, but this helper still owns the branch-completion decision flow when that workflow is needed internally.
-
-## Hard Gate
-
-`aw-test` and `aw-review` must have passed before this skill runs, or the compatibility umbrella must have recorded an equivalent verified outcome.
-If verification failed, route back to `aw-build`, `aw-test`, or `aw-review` instead of finishing.
-
-## Purpose
-
-Use this skill to close out verified branch work safely:
-
-- verify tests before offering completion choices
-- present explicit branch-completion options
-- execute the selected path
-- clean up the worktree only when appropriate
-
-If `.aw_docs/features/<feature_slug>/workspace.json` exists, use it as the source of truth for:
-
-- the active branch and worktree path
-- cleanup policy
-- orchestration coordination directory
-- the recommended `node scripts/orchestration-status.js ...` status command
-
-Staging or production deployment requests should stay on `aw-deploy`.
-
-## Deprecation Timeline
-
-This skill is still active internally even though `/aw:finish` is deprecated as a public entrypoint.
-Keep `aw-finish` available until `/aw:deploy` fully absorbs branch-completion choices, workspace metadata reuse, and cleanup behavior.
-Public deprecation must not be interpreted as immediate removal of the internal helper.
-
-## Completion Flow
-
-1. verify tests and validation signals still pass
-2. determine the base branch
-3. present exactly these choices:
-   - merge locally
-   - push and create PR
-   - keep as branch
-   - discard
-4. execute the selected path
-5. clean up the worktree when the selected path requires cleanup
-6. update or clear `workspace.json` to reflect the final cleanup decision
-
-## Required Options
-
-### Option 1: Merge Locally
-
-- switch to base branch
-- update from remote when appropriate
-- merge the verified branch
-- rerun the minimum correct verification
-- remove the branch or worktree when safe
-- clear `workspace.json` when cleanup completed successfully
-
-### Option 2: Push and Create PR
-
-- push the branch
-- create or update the PR with concise summary and test plan
-- keep the worktree if the branch remains active
-- preserve `workspace.json` for the active branch lifecycle
-
-### Option 3: Keep As-Is
-
-- keep the branch and worktree intact
-- report the branch name and next expected action
-- keep `workspace.json` intact for follow-up work
-
-### Option 4: Discard
-
-- require explicit confirmation
-- delete the branch or worktree only after confirmation
-- remove `workspace.json` only after cleanup succeeds
-
-## Worktree Cleanup Rule
-
-Only clean up the worktree automatically for:
-
-- merge-complete paths
-- confirmed discard paths
-
-Do not clean up the worktree for:
-
-- keep-as-branch
-- PR-open workflows where the branch is still in active use
-
-## Hard Gates
-
-- do not offer completion choices until tests are rechecked
-- do not discard work without explicit confirmation
-- do not turn branch completion into deployment orchestration
-- do not clean up an active PR worktree by accident
-
-## Final Output Shape
-
-Always end with:
-
-- `Verification Check`
-- `Base Branch`
-- `Completion Options`
-- `Selected Path`
-- `Cleanup Decision`

package/.cursor/skills/aw-investigate/SKILL.md

@@ -1,109 +0,0 @@
----
-name: aw-investigate
-description: Reproduce, localize, and confirm bugs, alerts, and regressions before broad fixes are attempted.
-trigger: User requests bug investigation, alert triage, root-cause analysis, or a legacy fix request arrives without a trustworthy cause.
----
-
-# AW Investigate
-
-## Overview
-
-`aw-investigate` is the public debugging and triage stage.
-It turns vague failure into concrete evidence, a likely fault surface, and a clear next step.
-
-## When to Use
-
-- root cause is unclear
-- the request starts from an alert, failure, log, or regression report
-- repeated fix attempts have already happened
-- the right next step might be "gather more evidence," not "change code"
-
-Do not use once the cause is already clear and implementation is ready.
-
-## Workflow
-
-1. Capture the failure signal.
-   Record the trigger, expected behavior, actual behavior, and current blast radius.
-2. Reproduce or isolate.
-   Use `aw-debug` and `../../references/debug-triage.md`.
-   For browser-visible issues, load `browser-testing-with-devtools`.
-   Prefer the smallest confirming probe over speculative patching.
-3. Load the right org-standard context.
-   Pull in relevant platform services, frontend, data, or infra playbooks.
-   For incident-style problems, load observability or log-analysis helpers as needed.
-4. Narrow the fault surface.
-   Identify the smallest plausible layer, file set, or dependency boundary.
-5. Decide the next stage.
-   If the cause is concrete enough, hand off to `aw-build` and name the exact starting slice or repair surface.
-   If the work still needs proof, stay in investigation and name the next probe explicitly instead of pausing with a vague "needs more digging" note.
-6. Persist the evidence.
-   Write `investigation.md` and update `state.json` with completed probes, open questions, and the recommended next command.
-
-## Completion Contract
-
-Investigation is complete only when one of these is true:
-
-- the likely fault surface is concrete enough for `aw-build`
-- the next probe is explicit enough for another investigation pass to continue without rediscovery
-- the work is blocked and the blocker is named clearly
-
-Every investigation handoff must make these things obvious:
-
-- what was reproduced
-- which probes were completed
-- what remains uncertain
-- which exact next command or next probe should run next
-
-## Common Rationalizations
-
-| Rationalization | Reality |
-|---|---|
-| "I already know the likely fix." | Likely is not the same as confirmed. |
-| "The third patch will probably work." | Repeated speculative fixes are a debugging failure. |
-| "I don't need logs or runtime evidence for this." | Alerts and regressions need concrete signals, not memory. |
-
-## Red Flags
-
-- fix attempts outnumber confirming probes
-- the failure is described only in prose, not evidence
-- the blast radius is guessed instead of scoped
-- the next action is "try another patch" instead of "run the next probe"
-
-## State File
-
-`state.json` should record at least:
-
-- `feature_slug`
-- `stage: "investigate"`
-- `mode`
-- `status`
-- written artifacts
-- completed probes
-- commands run
-- likely fault surface
-- open questions
-- blockers
-- recommended next commands
-
-## Verification
-
-Before leaving investigate, confirm:
-
-- [ ] reproduction or equivalent failure signal is captured
-- [ ] expected vs actual behavior is explicit
-- [ ] the likely fault surface is concrete enough to guide build
-- [ ] the next stage is clear: build, more investigation, or blocked
-- [ ] `investigation.md` and `state.json` are updated
-
-## Final Output Shape
-
-Always end with:
-
-- `Mode`
-- `Reproduction`
-- `Expected vs Actual`
-- `Evidence`
-- `Completed Probes`
-- `Likely Fault Surface`
-- `Open Questions`
-- `Next`