vibe-coding-master 0.7.5 → 0.7.7

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,4 +1,11 @@
 const REQUIRED_HEADINGS = {
+    "architecture-brief": [
+        "Accepted Outcome",
+        "Confirmed User Decisions",
+        "Existing Constraints",
+        "Unresolved User Decisions",
+        "User Confirmation"
+    ],
     "architecture-plan": [
         "Accepted Scope",
         "Current Code Reality",
@@ -103,6 +110,19 @@ 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();
         const invalidFields = result === "pass" || result === "fail"