vibe-coding-master 0.7.4 → 0.7.6

package/dist/backend/templates/harness/vcm-harness-bootstrap-skill.js

@@ -20,9 +20,10 @@ This skill is an operating procedure. It does not replace the deterministic VCM
 3. Fill project context: add or update non-managed project facts in \`CLAUDE.md\` above the VCM managed block.
 4. Fill durable docs: update \`docs/GLOSSARY.md\`, \`docs/CODING_STANDARDS.md\`, \`docs/ARCHITECTURE.md\`, module-level \`ARCHITECTURE.md\` files for clear non-root module boundaries, and \`docs/TESTING.md\` with detailed project-specific content.
 5. Preserve user-authored content and VCM managed blocks.
-6. Review \`git status\` and \`git diff\`.
-7. Stage only allowed bootstrap harness changes and create a commit in the active task worktree.
-8. Report evidence, commit hash, final git status, unknowns, confirmation-needed areas, generation failures, and recommended deterministic VCM actions.
+6. Run \`.ai/tools/check-durable-docs\` and correct every bootstrap-owned finding.
+7. Review \`git status\` and \`git diff\`.
+8. Stage only allowed bootstrap harness changes and create a commit in the active task worktree.
+9. Report evidence, durable-doc audit result, commit hash, final git status, unknowns, confirmation-needed areas, generation failures, and recommended deterministic VCM actions.
 
 ## Typical Outputs
 
@@ -49,6 +50,7 @@ This skill is an operating procedure. It does not replace the deterministic VCM
 - Run \`.ai/tools/generate-module-index\` when the generator exists and the project is supported.
 - Run \`.ai/tools/generate-public-surface\` only after \`.ai/generated/module-index.json\` exists.
 - If generation fails or the project is unsupported, report the reason. Do not invent generated artifacts.
+- Treat generated context as the source of truth for module inventories, manifests, dependencies, source/test file inventories, and complete public-surface listings. Durable prose may explain those facts but must not maintain separate counts or exhaustive lists that can drift.
 
 ### \`docs/GLOSSARY.md\`
 
@@ -69,6 +71,7 @@ This skill is an operating procedure. It does not replace the deterministic VCM
 - Document the project-level module overview, module responsibilities, module relationships, dependency direction, and project-wide constraints.
 - Link to module-level \`ARCHITECTURE.md\` files when present.
 - Explain generated-context ownership, especially that \`.ai/generated/public-surface.json\` is the machine index for public APIs, routes, and externally consumed surfaces.
+- Describe current architecture only. Do not import task history, implementation chronology, validation results, commit history, or completed-work reports from existing project material.
 
 ### Module-Level \`ARCHITECTURE.md\`
 
@@ -76,14 +79,22 @@ This skill is an operating procedure. It does not replace the deterministic VCM
 - Do not create a root-level \`ARCHITECTURE.md\` only because the root package exists.
 - Document module boundaries, responsibilities, allowed dependencies, important behavior, important public surface explanations, risks, and update triggers.
 - Keep complete public API listings in \`.ai/generated/public-surface.json\`; module docs should explain meaning and design intent, not duplicate the full generated index.
+- Keep source-file inventories, exhaustive callables, and implementation walkthroughs out of module architecture docs.
 
 ### \`docs/TESTING.md\`
 
 - Document validation levels, project-native validation commands, validation selection rules, final-validation cleanup, unit/integration test placement, generated-context freshness checks, and known testing gaps.
 - Document integration and E2E test cases as reviewable case lists. Each case should include ID, scenario, entry point, what it proves, key assertions, when to run, and current limitations when relevant.
 - Keep historical investigation details, superseded failures, temporary diagnostics, and per-task validation logs out of \`docs/TESTING.md\`.
+- Keep current strategy, runnable commands, behavior-level integration/E2E cases, selection rules, cleanup requirements, and current gaps; do not create an exhaustive test-function inventory.
 - Keep tester ownership of validation strategy and testing documentation clear.
 
+### Active Plans And Known Issues
+
+- Keep \`docs/plans/**\` limited to active or planned work. Remove completed or superseded plans from that collection; Git and PR history preserve them.
+- Keep \`docs/known-issues.md\` limited to current unresolved durable issues and accepted limitations. Remove resolved entries and rewrite partially resolved entries around the remaining current gap.
+- Do not preserve task chronology, role verdicts, validation history, or commit history in either collection.
+
 ### Commit
 
 - Create the bootstrap commit yourself after the allowed files are updated.

package/dist/backend/templates/harness/vcm-propose-memory-skill.js

@@ -4,8 +4,8 @@ Harness Review and provides an exact draft path.
 
 ## Rules
 
-- Treat \`.ai/vcm/memory/**\` as read-only. This skill creates a proposal; it
-  never edits active memory.
+- Treat every \`<VCM-memory>\` block as read-only. This skill creates a proposal;
+  it never edits active memory.
 - Write only to the exact draft path assigned by VCM. The path must be under
   \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` in the active task worktree.
 - If VCM did not provide a draft path, do not create a proposal.

package/dist/backend/templates/harness/vcm-route-message-skill.js

@@ -53,6 +53,9 @@ For PM dispatch, use:
 \`\`\`md
 ---
 type: task
+workflow_flow: code-change
+workflow_step: coder-implementation
+workflow_status: active
 artifact_refs:
   - .ai/vcm/handoffs/architecture-plan.md
   - docs/plans/example.md
@@ -74,6 +77,8 @@ Stop conditions:
 ...
 \`\`\`
 
+PM route files should declare the workflow checkpoint fields defined by the \`vcm-task-state\` skill. Non-PM reports must not declare workflow state.
+
 For non-PM reports, use:
 
 \`\`\`md

package/dist/backend/templates/harness/vcm-task-state-skill.js

@@ -0,0 +1,110 @@
+export function renderVcmTaskStateSkillRules() {
+    return `## Purpose
+
+Use this skill only as project-manager to declare the current task workflow checkpoint to VCM.
+
+The declaration is recoverable context, not a workflow controller. It does not authorize a transition, replace handoff artifacts, or decide the next role.
+
+## Declaration
+
+For a PM role dispatch, put the current declaration in the route-file frontmatter:
+
+\`\`\`yaml
+workflow_flow: code-change
+workflow_step: coder-implementation
+workflow_branch: none
+workflow_resume_point: none
+workflow_status: active
+workflow_evidence_refs: .ai/vcm/handoffs/architecture-plan.md
+\`\`\`
+
+For a checkpoint without a role route, run:
+
+\`\`\`bash
+.ai/tools/update-task-state --flow code-change --step awaiting-user --status awaiting-user
+\`\`\`
+
+Supply only fields that changed. Use \`none\` to clear branch or resume point. Repeat \`--evidence\` for evidence paths.
+
+Declare the selected flow before its first dispatch, update the step on later PM dispatches, and update no-route checkpoints such as waiting for the user, waiting for Gate Review, or completion.
+
+If declaration fails, report the warning when relevant and continue the existing workflow. Never delay routing, Gate Review, final acceptance, or task close because task state is unavailable.
+`;
+}
+export function renderUpdateTaskStateTool() {
+    return `#!/usr/bin/env python3
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+
+def emit(status, message=None, state=None):
+    payload = {"status": status}
+    if message:
+        payload["message"] = message
+    if state is not None:
+        payload["state"] = state
+    print(json.dumps(payload, ensure_ascii=False))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Declare advisory VCM task workflow state.")
+    parser.add_argument("--flow")
+    parser.add_argument("--step")
+    parser.add_argument("--branch")
+    parser.add_argument("--resume-point")
+    parser.add_argument("--status")
+    parser.add_argument("--evidence", action="append", default=[])
+    args = parser.parse_args()
+
+    if os.environ.get("VCM_ROLE") != "project-manager":
+        emit("warning", "Only project-manager may declare VCM task workflow state.")
+        return 0
+
+    api_url = os.environ.get("VCM_API_URL", "").rstrip("/")
+    task_slug = os.environ.get("VCM_TASK_SLUG", "").strip()
+    if not api_url or not task_slug:
+        emit("warning", "VCM_API_URL or VCM_TASK_SLUG is unavailable; task state was not updated.")
+        return 0
+
+    payload = {}
+    for key, value in (
+        ("flow", args.flow),
+        ("step", args.step),
+        ("branch", args.branch),
+        ("resumePoint", args.resume_point),
+        ("status", args.status),
+    ):
+        if value is not None:
+            payload[key] = value
+    if args.evidence:
+        payload["evidenceRefs"] = args.evidence
+
+    if not payload:
+        emit("warning", "No task workflow fields were supplied.")
+        return 0
+
+    url = f"{api_url}/api/tasks/{urllib.parse.quote(task_slug, safe='')}/workflow-state"
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={"content-type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=3) as response:
+            state = json.loads(response.read().decode("utf-8"))
+        emit("updated", state=state)
+    except (OSError, ValueError, urllib.error.URLError, urllib.error.HTTPError) as error:
+        emit("warning", f"Task state was not updated: {error}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+`;
+}

package/dist/backend/templates/message-envelope.js

@@ -27,5 +27,5 @@ Instructions:
 }
 export function renderManualStagePrompt(message) {
     const target = message.bodyPath ?? `VCM message ${message.id}`;
-    return `Read and handle VCM message ${message.id} at ${target}`;
+    return `[VCM MESSAGE]\nid: ${message.id}\nRead and handle the VCM message at ${target}.\n[/VCM MESSAGE]`;
 }

package/dist/shared/constants.js

@@ -84,16 +84,6 @@ export function isHarnessEngineerToolRoleName(value) {
 export function isDispatchableRole(value) {
     return DISPATCHABLE_ROLES.includes(value);
 }
-/**
- * Roles that address the human operator. When a role in this set ends its turn
- * with no onward route message, the flow is treated as awaiting a user decision
- * (see the `awaiting-user` flow-pause reason). Single source of truth for that
- * predicate.
- */
-export const USER_FACING_ROLES = ["project-manager"];
-export function isUserFacingRole(value) {
-    return USER_FACING_ROLES.includes(value);
-}
 export function getRoleDefinition(role) {
     const definition = ROLE_DEFINITIONS.find((candidate) => candidate.name === role);
     if (!definition) {

package/dist/shared/types/workflow.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/validation/artifact-check.js

@@ -1,8 +1,27 @@
 const REQUIRED_HEADINGS = {
+    "architecture-brief": [
+        "Accepted Outcome",
+        "Confirmed User Decisions",
+        "Existing Constraints",
+        "Unresolved User Decisions",
+        "User Confirmation"
+    ],
     "architecture-plan": [
         "Accepted Scope",
         "Current Code Reality",
+        "Planning Boundary",
+        "Code Reading Evidence",
+        "Existing Behavior Trace",
+        "Code / Docs Conflicts",
         "Architecture Decision",
+        "Changed Behavior Flow",
+        "Ownership",
+        "Data Flow",
+        "Lifecycle",
+        "Boundaries",
+        "Invariants",
+        "Failure Model",
+        "Decision Rationale",
         "Module/File Plan",
         "Public Surface Impact",
         "Scaffold Manifest",
@@ -18,6 +37,7 @@ const REQUIRED_HEADINGS = {
     "test-report": [
         "Evidence Reviewed",
         "Tests Added Or Updated",
+        "Coverage Mapping",
         "Commands Run Or Checked",
         "Validation Results",
         "Failed Expectations",
@@ -90,11 +110,31 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
     };
 }
 function validateArtifactFields(kind, content) {
+    if (kind === "architecture-brief") {
+        const status = /^\s*Architecture Brief Status\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
+        const invalidFields = status === "interviewing" || status === "confirmed"
+            ? []
+            : ["Architecture Brief Status must be interviewing or confirmed."];
+        if (status === "confirmed") {
+            const unresolved = readArtifactSectionValue(content, "Unresolved User Decisions");
+            if (!unresolved || !/^none\.?$/i.test(unresolved)) {
+                invalidFields.push("Unresolved User Decisions must be None when Architecture Brief Status is confirmed.");
+            }
+        }
+        return invalidFields;
+    }
     if (kind === "test-report") {
         const result = /^\s*Test Result\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
-        return result === "pass" || result === "fail"
+        const invalidFields = result === "pass" || result === "fail"
             ? []
             : ["Test Result must be pass or fail."];
+        if (result === "pass") {
+            const blockingIssues = readArtifactSectionValue(content, "Blocking Validation Issues");
+            if (!blockingIssues || !/^none\.?$/i.test(blockingIssues)) {
+                invalidFields.push("Blocking Validation Issues must be None when Test Result is pass.");
+            }
+        }
+        return invalidFields;
     }
     if (kind === "docs-sync-report") {
         return validateDecision(content, ["synced", "unchanged", "blocked"]);