AGENT SKILL

continue-implementation

Use when the user asks Pi to continue implementation, continue-implementing, resume implementation, or run a HEPHA FEAT implementation such as "use the skill continue implementation for FEAT-002" from a registered project workspace.

License 许可
MIT
最近更新
2026-10-31
Stars
★ 0
Forks
0

01 前言 Front Matter

name
continue-implementation
description
Use when the user asks Pi to continue implementation, continue-implementing, resume implementation, or run a HEPHA FEAT implementation such as "use the skill continue implementation for FEAT-002" from a registered project workspace.
agent_action
continue-implementing

03 SKILL.md 正文

Continue Implementation

Model Authority

This procedure is model-neutral. When invoked directly, execution is direct_host and remains in the current Pi, Codex, or Claude Code session; that active host owns model selection. Do not query Hepha routing policy, request a model switch, automatically hand off, choose a fallback model, or fabricate route-policy evidence. Direct execution does not fabricate an orchestrated receipt. Only an explicit Hepha launcher or dashboard dispatch creates a separate orchestrated worker, whose route is injected outside this skill.

You are executing the HEPHA continue-implementing workflow directly from Pi.

This skill is for the direct Pi workflow, not for clicking the dashboard. It must work when Pi is opened from a registered project or a parent workspace and the user names the active project and a FEAT id such as FEAT-002.

Objective

Resolve the active HEPHA project and MemoryBank, locate the requested FEAT, read its PhaseExecutionContract.json, and continue the first unresolved declared phase autonomously in contract order until every declared phase is COMPLETED or SKIPPED, or until a real blocker requires human input.

Required Inputs

Accept these from the user's message:

  • project name or alias, such as HEPHA, Hepha, or AgenticDevelopmentProcess;
  • FEAT id, such as FEAT-002;
  • optional MemoryBank path override;
  • optional mode, where autonomous means continue through subsequent phases without stopping after one phase.

If the FEAT id is missing, ask one concise question. Otherwise, infer safely.

Workspace And Project Resolution

  1. Treat the current directory as the workspace starting point.
  2. Resolve the active project named by the user and locate its repository root.
  3. Read the project AGENTS.md and project brief or MemoryBank overview when present before editing.
  4. Resolve the active project:
    • HEPHA, Hepha, and AgenticDevelopmentProcess map to <workspace root>/AgenticDevelopmentProcess.
    • If the user names another project, use docs/projects.md or the nearest child repo folder matching that name.
  5. Read the child project AGENTS.md and README.md when present.
  6. Run project git, build, test, and edit commands from the child project root, not from the parent workspace.

MemoryBank Resolution

Resolve the MemoryBank in this order:

  1. User-supplied MemoryBank path, if present.
  2. .hepha/projects.json in the child project, matching project name, id, or child root path.
  3. <child project root>/MemoryBank when it contains Features/.
  4. A direct search under the child root for MemoryBank/Features.

Stop with a blocker if no MemoryBank with Features/ exists.

FEAT Resolution

  1. Normalize the requested FEAT id to uppercase, for example FEAT-002.
  2. Search these folders under <MemoryBank>/Features:
    • 03_IN_PROGRESS first;
    • then 02_READY_TO_DEVELOP, 01_SUBMITTED, 04_COMPLETED, and 05_CANCELLED only for diagnostics.
  3. Match a FEAT folder by folder name or by FeatureDescription.md content.
  4. Continue implementation only when the FEAT is in 03_IN_PROGRESS.
  5. Require FeatureDescription.md, FeatureTasks.md, PhaseExecutionContract.json, and every phase document declared by that contract.
  6. If the FEAT contains [NEEDS VALIDATION], stop and report the exact file and line references. Do not implement while validation markers remain.

Phase Resolution

Build the phase inventory before editing. PhaseExecutionContract.json is the only source of topology and ordering. Do not infer execution order from a Markdown title, filename, or display number:

  1. Read FeatureTasks.md.
  2. Read and validate PhaseExecutionContract.json, then read exactly the phase documents declared there.
  3. Parse phase status from the FeatureTasks.md contract inventory first, then from a phase file status line such as **Status:** COMPLETED.
  4. Normalize statuses:
    • Completed, Complete -> COMPLETED
    • Skipped, N/A -> SKIPPED
    • Not Started, NOT_STARTED, Pending -> PENDING
    • In Progress -> IN_PROGRESS
    • Awaiting Review -> AWAITING_REVIEW
    • Code Review In Progress -> CODE_REVIEW_IN_PROGRESS
    • Awaiting User Acceptance -> AWAITING_USER_ACCEPTANCE
    • Blocked, Failed, Rejected -> BLOCKED
  5. Stop with a blocker if the execution contract is missing, invalid, or its declared documents do not match the Phases/ directory.
  6. The current phase is the first contract-ordered phase that is not COMPLETED or SKIPPED, unless a review-finding report clearly requires returning to a specific earlier phase.
  7. If every contract phase is COMPLETED or SKIPPED, scan each phase's ## Quality Gate Evidence table. If any gate decision is missing, treat the first contract-ordered phase with a missing gate as the current phase for quality-gate repair only.

Autonomous Phase Loop

When the user says autonomous, continue through phases in execution-contract order:

  1. Start at the current unresolved phase.
  2. Complete or skip only that phase's scoped work.
  3. Update durable task evidence and narrative notes in the phase document. Hepha owns lifecycle/status fields and FeatureTasks status cells.
  4. Run focused verification.
  5. Run review when needCodeReview is true.
  6. Fix blocking review findings and rerun focused verification.
  7. Record completion or skip evidence; Hepha deterministically writes COMPLETED or SKIPPED after validating it.
  8. Rescan phases from disk.
  9. Continue to the next unresolved contract phase.

Stop only when:

  • all declared contract phases are COMPLETED or SKIPPED;
  • all phase quality gates are satisfied, waived, or not applicable;
  • a real blocker requires human judgment;
  • credentials, permissions, missing dependency, or unsafe action prevents safe progress;
  • the same failure repeats after a documented focused recovery attempt.

Per-Phase Work Rules

Before changing code in a phase:

  • Read the phase document.
  • Read planning-analysis-report.md whenever the current contract phase's planning-index row identifies it as required context.
  • Read relevant parent EPIC and FEAT acceptance criteria, including linked EpicAcceptanceTests.md scenarios and the current phase's EPIC Acceptance Traceability assignments in FeatureTasks.md when present.
  • Read applicable MemoryBank/LessonsLearned documents.
  • Inspect current git status from the child project root.
  • Preserve existing checked Markdown checklist items.
  • If the phase has no checkbox ledger, add a compact ## Phase Task Ledger before substantive work.

During implementation:

  • Work only the current phase scope.
  • Skip checked tasks unless a changed file, failed verification, or review finding explicitly invalidates them.
  • Do not edit reserved machine fields: **Status:**, FeatureTasks Status cells, or Quality Gate Evidence Decision cells. Hepha writes them from durable workflow events.
  • Record task progress and evidence; Hepha applies the lifecycle transition.
  • Do not broaden scope to dashboard/UI/sync behavior unless the phase explicitly requires it.
  • Do not move the FEAT folder between MemoryBank state folders.
  • Do not start dev servers, watch commands, or long-running UI processes.
  • Do not push to remotes.
  • Do not revert unrelated user changes.

Verification Rules

Apply the serialized-build-commands skill when available before running build, test, lint, format, Cargo, pnpm, npm, or other shared-state commands.

Run one verification command at a time. Wait for the result, inspect it, then decide the next command.

Prefer focused phase verification first. Run broad verification only when the phase or final checkpoint requires it and the narrower checks are green.

Do not invent test results. Record exact commands and observed outcomes in the phase evidence.

When a phase-selected validation fails and the phase declares repair_and_rerun, repair the directly responsible production code, test, fixture, configuration, or shared contract, then rerun the validation. The expected-file list is a delivery forecast; it does not authorize relabelling a configured failure as out of scope or complete.

The final ## Hepha Gate Evidence Handoff must use the exact three-column Gate | Result | Evidence schema. Changed files use recorded; Tests and Gherkin/Playwright E2E use exactly passed, failed, or not_applicable. Failed, timed-out, skipped, or crashing required checks use failed and cannot complete the active task.

The phase declarations are authoritative: needCodeReview and needTestCoverage are independent booleans; all four combinations are valid. Ordered native tasks and explicit configured checks retain their own obligations. Phase identifiers, positions, titles and file types never select gates. Developers can revise declarations with before/after values, implemented scope, reason and evidence, without hiding failures. Reuse valid evidence for unchanged inputs. Ordinary missing tests or rejected reviews remain same-phase repair work; escalate only a concrete impasse or repeated lack of a meaningful repair path.

Phase Quality Gate Evidence

Agents write evidence in phase documents. Hepha owns the machine-readable lifecycle fields (**Status:** and FeatureTasks Status) and Quality Gate Decision cells. Do not alter those reserved fields. New phase documents created by RefineFeature use this table:

Gate Decision Evidence / Justification
Changed files satisfied/waived/not applicable/missing Use satisfied when the exact changed paths are recorded; use a justified waiver only where appropriate.
Tests satisfied/waived/not applicable/missing Exact test files and commands, or a waiver explaining why tests are not useful for this phase.
Gherkin/Playwright E2E satisfied/waived/not applicable/missing Required only at the explicitly assigned workflow execution owner; retain EPIC E2E updates and execution links alongside phase TwinTests.
Code review satisfied/waived/not applicable/missing Phase review report path, or an explicit waiver and risk rationale.

Rules:

  • Hepha writes Decision cells using exactly one canonical value: missing, satisfied, waived, or not applicable. Do not put synonyms such as pass, passed, recorded, complete, or approved in the Decision cell.

  • Keep every Quality Gate Evidence entry on exactly one physical Markdown table row: it must start and end with | and contain the three template columns. Put all evidence in the third cell on that same line; never wrap or continue a gate row onto a following line.

  • Follow the declared coverage and review flags with scope reasons for N/A. Execute independently required checks even when both flags are false.

  • UI changes may require frontend TwinTests and EPIC E2E updates. Run full-workflow E2E at its declared owner; a passing TwinTest never waives it.

  • Do not claim a phase is complete with a required missing gate. Supply the missing evidence or justification and let Hepha retain the lifecycle state.

  • Do not mark a phase complete while an EPIC acceptance scenario assigned to that phase lacks its planned executable evidence or an exact documented existing-coverage mapping.

Quality-Gate Repair Mode

When all implementation phase work is already completed but one or more phase quality gates are missing, do not redo completed implementation tasks. Work only the missing gates:

  • Missing Code review: inspect the declared review obligation and existing report. When required, repair findings and obtain approval for the applicable scope. If scope changed, record a justified declaration revision; do not infer review applicability from file types or directly overwrite machine-owned decision cells.
  • Missing Tests: inspect the declared acceptance coverage and required commands. Reuse valid execution and assertion evidence, repair missing meaningful coverage, and execute missing or invalidated required checks. A justified declaration revision must preserve actual failures and the remaining obligations.
  • Missing Gherkin/Playwright E2E: inspect the assigned workflow obligation and original execution evidence. Repair and execute that obligation at its declared owner; isolated tests cannot replace a required full-workflow check.
  • Preserve completed phase implementation task checkboxes. Do not broaden scope beyond the missing gate unless a review finding requires a fix.

Review Rules

When needCodeReview is true:

  1. Perform a dedicated review pass after implementation and focused checks.
  2. Review changed files first, then required phase/status/evidence context.
  3. Write a concise review report under the FEAT folder's code-reviews/ directory when the project convention uses review artifacts.
  4. Treat BLOCKER/REQUIRED findings as mandatory fixes.
  5. Evaluate notes and polish findings explicitly as fixed, deferred, accepted-risk, rebutted, or follow-up.
  6. Do not mark the phase complete while blocking findings remain.

If a previous review report exists for the current phase and says NEEDS_CHANGES, begin by resolving those findings instead of restarting normal implementation.

Output Contract

At the end of the run, report:

  • project root and MemoryBank path used;
  • FEAT id and folder;
  • phases completed/skipped during this run;
  • current phase after the run;
  • verification commands and results;
  • blocker, if any;
  • changed files.

Keep the final summary concise and concrete.

04 同仓库更多 Skills

aboimpinto
aboimpinto/AgenticDevelopmentProcess

serialized-build-commands

Agents should invoke this skill before running build, test, lint, or format commands that use shared caches, file locks, build directories, or package manager state. Use especially before Rust Cargo commands such as cargo check, cargo test, cargo clippy, cargo fmt, cargo build, or any shell command containing cargo.

★ 0
aboimpinto
aboimpinto/AgenticDevelopmentProcess

submit-epic

Use when the user asks Pi to submit, create, or draft a new HEPHA EPIC directly from a registered project workspace, preserving the useful legacy DevCycle MCP submit-epic command, for example "submit-epic for HEPHA build observability projection hooks" or "create a HEPHA EPIC titled Runtime Approval Gates".

★ 0
aboimpinto
aboimpinto/AgenticDevelopmentProcess

start-feature

Use when the user asks Pi to start a HEPHA FEAT implementation, run start-feature, or run start-implementing for a READY FEAT from a registered project workspace, for example "use the start-feature skill for FEAT-003".

★ 0
aboimpinto
aboimpinto/AgenticDevelopmentProcess

refine-feature

Use when the user asks Pi to run refine-feature, refine a HEPHA FEAT, create FeatureTasks and phase files, or move a clarified FEAT to Ready To Develop, for example "refine-feature FEAT-004" or "Use the refine-feature skill for HEPHA FEAT-004".

★ 0
aboimpinto
aboimpinto/AgenticDevelopmentProcess

design-feature

Use when the user asks Pi to run design-feature, design a HEPHA FEAT, create UI requirements, or prepare UX/design artifacts for a FEAT, for example "design-feature FEAT-004" or "Use the design-feature skill for HEPHA FEAT-004".

★ 0
aboimpinto
aboimpinto/AgenticDevelopmentProcess

deep-dive

Use when the user asks Pi to run a HEPHA Deep-Dive for an EPIC or FEAT, gather Deep-Dive questions, or apply saved Deep-Dive answers to a MemoryBank document, for example "use the deep-dive skill for HEPHA FEAT-004".

★ 0