vibe-coding-master 0.8.10 → 0.8.12

package/dist/backend/services/workflow-control-service.js

@@ -189,6 +189,9 @@ export function createWorkflowControlService(deps) {
             await assertRouteAuthorized(input);
             const state = await getState(input);
             const pending = state.pendingDispatch;
+            const timestamp = now();
+            const progress = await readProgress(deps.fs, input);
+            const evidenceBaseline = await captureEvidenceBaseline(deps.fs, input, progress.history.length + 1, pending.effectiveFlow, pending.targetRole, timestamp);
             await saveState(input, {
                 ...state,
                 pendingDispatch: {
@@ -196,7 +199,8 @@ export function createWorkflowControlService(deps) {
                     status: "dispatching",
                     routeContentHash: input.routeContentHash,
                     messageId: input.messageId,
-                    updatedAt: now()
+                    evidenceBaseline,
+                    updatedAt: timestamp
                 },
                 updatedAt: now()
             });
@@ -215,18 +219,37 @@ export function createWorkflowControlService(deps) {
                     status: "pending",
                     routeContentHash: undefined,
                     messageId: undefined,
+                    confirmationError: undefined,
+                    evidenceBaseline: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
             });
         });
     }
+    async function markDispatchUnconfirmed(input, messageId, reason) {
+        await withLock(statePath(input), async () => {
+            const state = await getState(input);
+            const pending = state.pendingDispatch;
+            if (!pending || pending.status !== "dispatching" || pending.messageId !== messageId)
+                return;
+            await saveState(input, {
+                ...state,
+                pendingDispatch: { ...pending, confirmationError: reason, updatedAt: now() },
+                updatedAt: now()
+            });
+        });
+    }
     async function cancelPendingDispatch(input) {
         await withLock(statePath(input), async () => {
             const state = await getState(input);
             const pending = state.pendingDispatch;
             if (!pending)
                 return;
+            if (pending.status === "dispatching" && !pending.confirmationError) {
+                throw workflowError("WORKFLOW_DISPATCH_PENDING", `Message ${pending.messageId} is being delivered and cannot be cleared before confirmation.`);
+            }
+            const timestamp = now();
             const progress = await readProgress(deps.fs, input);
             await commitStateAndProgress(input, renderWorkflowProgress({
                 ...progress,
@@ -234,21 +257,26 @@ export function createWorkflowControlService(deps) {
             }), {
                 ...state,
                 pendingDispatch: null,
-                userAuthorizations: state.userAuthorizations.filter((entry) => entry.id !== pending.overrideAuthorizationId),
-                userApprovedFollowUps: state.userApprovedFollowUps.filter((entry) => entry.id !== pending.followUpApprovalId),
-                updatedAt: now()
+                ...abandonPendingApprovals(state, pending, "Pending route was cleared before confirmation.", timestamp),
+                updatedAt: timestamp
             });
         });
     }
-    async function confirmDispatch(input, messageId) {
+    async function confirmDispatch(input, messageId, source = "hook") {
         await withLock(statePath(input), async () => {
             const state = await getState(input);
-            failOnStateWarnings(state);
+            failOnStateWarnings({
+                ...state,
+                warnings: state.warnings.filter((warning) => warning !== unconfirmedDispatchWarning(state.pendingDispatch))
+            });
             failWhileAwaitingUser(state);
             const pending = state.pendingDispatch;
             if (!pending || pending.status !== "dispatching" || pending.messageId !== messageId) {
                 throw workflowError("WORKFLOW_DISPATCH_CONFIRMATION_MISMATCH", `Message ${messageId} does not own the pending workflow dispatch.`, "Do not advance Workflow Progress from an unrelated UserPromptSubmit event.");
             }
+            if (source === "manual" && !pending.confirmationError) {
+                throw workflowError("WORKFLOW_DISPATCH_NOT_UNCONFIRMED", "Manual confirmation is only available for a delivered dispatch whose confirmation failed.");
+            }
             const current = await readProgress(deps.fs, input);
             if (current.revision !== pending.revision || historyHash(current.history) !== pending.baseHistoryHash) {
                 throw workflowError("WORKFLOW_APPROVAL_STALE", "Workflow Progress changed before the approved dispatch was confirmed.", "Repair workflow-progress.md before continuing.");
@@ -258,12 +286,14 @@ export function createWorkflowControlService(deps) {
                 sequence: current.history.length + 1,
                 flow: pending.effectiveFlow,
                 targetRole: pending.targetRole,
-                evidence: pending.evidence,
+                evidence: source === "manual"
+                    ? `${pending.evidence} [User manually confirmed execution of message ${messageId}.]`
+                    : pending.evidence,
                 overrideAuthorizationId: pending.overrideAuthorizationId,
                 followUpApprovalId: pending.followUpApprovalId,
                 confirmedAt: timestamp
             };
-            const activeDispatch = await captureEvidenceBaseline(deps.fs, input, entry.sequence, entry.flow, entry.targetRole, timestamp);
+            const activeDispatch = pending.evidenceBaseline ?? await captureEvidenceBaseline(deps.fs, input, entry.sequence, entry.flow, entry.targetRole, timestamp);
             const flowRun = await advanceFlowRun(deps.fs, input, state, current, pending.effectiveFlow, entry.sequence);
             const completed = {
                 ...current,
@@ -293,8 +323,24 @@ export function createWorkflowControlService(deps) {
         return withLock(statePath(input), async () => {
             await recoverCommitJournal(input);
             const state = await getState(input);
-            if (state.warnings.length > 0 || state.pendingDispatch?.status !== "dispatching")
+            if (state.pendingDispatch?.status !== "dispatching"
+                || state.warnings.some((warning) => warning !== unconfirmedDispatchWarning(state.pendingDispatch)))
                 return false;
+            if (await wasDispatchDelivered(deps.fs, input, state.pendingDispatch.messageId)) {
+                if (state.pendingDispatch.confirmationError)
+                    return false;
+                const timestamp = now();
+                await saveState(input, {
+                    ...state,
+                    pendingDispatch: {
+                        ...state.pendingDispatch,
+                        confirmationError: "VCM restarted before the delivered message received UserPromptSubmit confirmation.",
+                        updatedAt: timestamp
+                    },
+                    updatedAt: timestamp
+                });
+                return true;
+            }
             await saveState(input, {
                 ...state,
                 pendingDispatch: {
@@ -302,6 +348,8 @@ export function createWorkflowControlService(deps) {
                     status: "pending",
                     routeContentHash: undefined,
                     messageId: undefined,
+                    confirmationError: undefined,
+                    evidenceBaseline: undefined,
                     updatedAt: now()
                 },
                 updatedAt: now()
@@ -323,6 +371,7 @@ export function createWorkflowControlService(deps) {
         assertRouteAuthorized,
         claimDispatch,
         releaseDispatch,
+        markDispatchUnconfirmed,
         cancelPendingDispatch,
         confirmDispatch,
         recoverTask
@@ -361,10 +410,12 @@ export function createWorkflowControlService(deps) {
     async function requestUserInput(input, question) {
         return withLock(statePath(input), async () => {
             const state = await getState(input);
-            failOnStateWarnings(state);
             if (state.pendingDispatch?.status === "dispatching") {
-                throw workflowError("WORKFLOW_DISPATCH_PENDING", "A role dispatch is already being submitted and cannot be canceled by a user question.", "Wait for the target UserPromptSubmit confirmation or recover the dispatch before asking the user.");
+                throw workflowError("WORKFLOW_DISPATCH_PENDING", state.pendingDispatch.confirmationError
+                    ? `A delivered role dispatch is unconfirmed: ${state.pendingDispatch.confirmationError}`
+                    : "A role dispatch is already being submitted and cannot be canceled by a user question.", "Inspect the target session and confirm or clear the pending dispatch before asking the user.");
             }
+            failOnStateWarnings(state);
             const normalizedQuestion = question.trim();
             if (!normalizedQuestion) {
                 throw workflowError("WORKFLOW_USER_QUESTION_REQUIRED", "A non-empty user question is required.");
@@ -378,8 +429,7 @@ export function createWorkflowControlService(deps) {
                     requestedAt: timestamp
                 },
                 pendingDispatch: null,
-                userAuthorizations: state.userAuthorizations.filter((entry) => entry.id !== pending?.overrideAuthorizationId),
-                userApprovedFollowUps: state.userApprovedFollowUps.filter((entry) => entry.id !== pending?.followUpApprovalId),
+                ...(pending ? abandonPendingApprovals(state, pending, "PM asked the user before dispatch confirmation.", timestamp) : {}),
                 updatedAt: timestamp
             };
             if (pending) {
@@ -1226,6 +1276,9 @@ function validateCandidateAgainstCurrent(current, candidate) {
 function stateProgressConsistencyWarnings(state, progress) {
     const warnings = [];
     const pending = state.pendingDispatch;
+    const unconfirmedWarning = unconfirmedDispatchWarning(pending);
+    if (unconfirmedWarning)
+        warnings.push(unconfirmedWarning);
     if (!pending && progress.proposal) {
         warnings.push("Workflow Progress contains a dispatch proposal without a runtime approval.");
     }
@@ -1248,6 +1301,40 @@ function stateProgressConsistencyWarnings(state, progress) {
     }
     return warnings;
 }
+function unconfirmedDispatchWarning(pending) {
+    return pending?.confirmationError
+        ? `PM dispatch ${pending.messageId ?? "unknown"} to ${pending.targetRole} was delivered but not confirmed: ${pending.confirmationError} Inspect the target session and use Confirm Executed if it already ran; do not resend executed work.`
+        : undefined;
+}
+function abandonPendingApprovals(state, pending, reason, timestamp) {
+    return {
+        userAuthorizations: state.userAuthorizations.map((entry) => entry.id === pending.overrideAuthorizationId
+            ? { ...entry, status: "abandoned", abandonedAt: timestamp, abandonReason: reason }
+            : entry),
+        userApprovedFollowUps: state.userApprovedFollowUps.map((entry) => entry.id === pending.followUpApprovalId
+            ? { ...entry, status: "abandoned", abandonedAt: timestamp, abandonReason: reason }
+            : entry)
+    };
+}
+async function wasDispatchDelivered(fs, input, messageId) {
+    if (!messageId)
+        return false;
+    const messagesPath = path.join(input.taskRepoRoot, input.stateRoot, "messages", `${input.taskSlug}.jsonl`);
+    if (!(await fs.pathExists(messagesPath)))
+        return false;
+    try {
+        let latest;
+        for (const line of (await fs.readText(messagesPath)).split(/\r?\n/).filter(Boolean)) {
+            const message = JSON.parse(line);
+            if (message.id === messageId)
+                latest = message;
+        }
+        return Boolean(latest?.deliveredAt);
+    }
+    catch {
+        return true;
+    }
+}
 function createUserAuthorization(authorizationId, current, candidate, effectiveFlow, baseHistoryHash, violation, authorizationText, timestamp) {
     return {
         id: authorizationId,
@@ -1492,6 +1579,8 @@ function isPendingDispatch(value) {
         && (value.status === "pending" || value.status === "dispatching")
         && (value.routeContentHash === undefined || typeof value.routeContentHash === "string")
         && (value.messageId === undefined || typeof value.messageId === "string")
+        && (value.confirmationError === undefined || typeof value.confirmationError === "string")
+        && (value.evidenceBaseline === undefined || Boolean(normalizeDispatchEvidenceBaseline(value.evidenceBaseline)))
         && typeof value.createdAt === "string"
         && typeof value.updatedAt === "string";
 }
@@ -1499,7 +1588,7 @@ function isUserAuthorization(value) {
     if (!isRecord(value))
         return false;
     return typeof value.id === "string"
-        && (value.status === "accepted" || value.status === "consumed")
+        && (value.status === "accepted" || value.status === "consumed" || value.status === "abandoned")
         && value.role === "project-manager"
         && value.operation === "workflow-dispatch"
         && Number.isInteger(value.baseRevision)
@@ -1511,13 +1600,15 @@ function isUserAuthorization(value) {
         && typeof value.violatedRule === "string"
         && typeof value.authorizationText === "string"
         && typeof value.createdAt === "string"
-        && (value.consumedAt === undefined || typeof value.consumedAt === "string");
+        && (value.consumedAt === undefined || typeof value.consumedAt === "string")
+        && (value.abandonedAt === undefined || typeof value.abandonedAt === "string")
+        && (value.abandonReason === undefined || typeof value.abandonReason === "string");
 }
 function isUserApprovedFollowUp(value) {
     if (!isRecord(value))
         return false;
     return typeof value.id === "string"
-        && (value.status === "accepted" || value.status === "consumed")
+        && (value.status === "accepted" || value.status === "consumed" || value.status === "abandoned")
         && value.role === "project-manager"
         && value.operation === "post-validation-follow-up"
         && Number.isInteger(value.baseRevision)
@@ -1529,7 +1620,9 @@ function isUserApprovedFollowUp(value) {
         && typeof value.evidence === "string"
         && typeof value.approvalText === "string"
         && typeof value.createdAt === "string"
-        && (value.consumedAt === undefined || typeof value.consumedAt === "string");
+        && (value.consumedAt === undefined || typeof value.consumedAt === "string")
+        && (value.abandonedAt === undefined || typeof value.abandonedAt === "string")
+        && (value.abandonReason === undefined || typeof value.abandonReason === "string");
 }
 function normalizeDispatchEvidenceBaseline(value) {
     if (!isRecord(value) || !isRecord(value.artifactHashes) || !isRecord(value.gateFingerprints))

package/dist/backend/templates/harness/architect-agent.js

@@ -22,7 +22,7 @@ ${renderRoleMemoryRules("architect")}
 ### Semantic Code Navigation
 
 - Follow the preloaded \`vcm-code-navigation\` skill whenever work requires code definitions, implementations, references, callers, callees, or behavior paths. This applies in every Architect mode and in direct user communication.
-- LSP is mandatory and directly available for navigating project source code. Start source-code navigation with LSP. If it is unavailable, report a VCM LSP configuration failure; do not substitute source text search.
+- LSP is mandatory for navigating project source code. Start source-code navigation with a registered LSP server. If a required language server is unavailable, stop the affected work and report its language, command, error, and installation hint through the current communication channel. Resume after the environment is fixed and Architect is restarted; do not substitute source text search.
 - Use LSP definitions, implementations, references, document or workspace symbols, and incoming or outgoing calls for all source-code symbol and relationship queries.
 - LSP reference results are symbol-specific. An accessor, its backing field, a trait declaration, its implementation method, a wrapper, and an alias are separate symbols. Query every relevant symbol separately; one symbol's reference result cannot prove a complete semantic class. When starting from an accessor or wrapper, read its implementation, resolve its backing field, delegate, or trait item with LSP, then query those symbols too.
 - Do not use the built-in \`Grep\` tool or shell text-search commands such as \`grep\`, \`rg\`, \`git grep\`, \`ag\`, or \`ack\` to search project source code, test code, or executable scripts, except for the bounded fallback below. This prohibition includes locating or inferring definitions, implementations, references, callers, callees, symbols, and behavior paths.
@@ -141,7 +141,7 @@ ${renderRoleMemoryRules("architect")}
 #### Code Scaffolding
 
 - Use the Agent tool to invoke \`vcm-architect-scaffold-worker\` in the foreground after the plan and Scaffold Manifest are complete. Give it the exact plan path and require it to return before this Architect turn continues.
-- Use one scaffold worker. Do not run it in the background or end the Architect turn while it is active.
+- Run at most one scaffold worker at a time. Do not run it in the background or end the Architect turn while it is active. If its report leaves scaffold items unfinished, verify the completed work and invoke another foreground scaffold worker with the previous report and exact remaining items. Continue until every item is complete or report the concrete failure to project-manager.
 - Review the worker commit, actual diff, callable surfaces, marker placement, ledger reconciliation, and L0 results yourself. Architect owns every final scaffold claim and must correct any worker error before marking planning complete.
 - Create or update only the minimum module/file scaffolding needed to make boundaries, callable surfaces, and placeholders unambiguous. Minimum limits depth (no business implementation), never breadth: every \`create\`, \`change\`, and \`delete\` item must be scaffolded.
 - When a required configuration, package manifest, or build-definition change cannot safely contain a \`VCM:CODE\` marker, complete and commit it directly as Architect-owned scaffold work. Record it in the Module/File Plan and Scaffold Build Evidence. Do not add it to the Scaffold Manifest.

package/dist/backend/templates/harness/vcm-code-navigation-skill.js

@@ -6,7 +6,7 @@ Use this skill when Architect must establish symbol definitions, implementations
 ## Navigation Order
 
 1. Define the affected feature or module boundary and locate entry symbols with \`.ai/generated/module-index.json\` and \`.ai/generated/public-surface.json\` when available.
-2. Use LSP workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships. If \`LSP\` is unavailable, report a VCM LSP configuration failure instead of substituting text search.
+2. Use LSP workspace or file symbols, definitions, implementations, references, and incoming or outgoing call hierarchy to resolve project-owned relationships. If a required language server is unavailable, stop the affected work and report its language, command, error, and installation hint through the current communication channel. Resume after the environment is fixed and Architect is restarted; do not substitute text search.
 3. Treat LSP results as symbol-specific. An accessor, backing field, trait declaration, implementation method, wrapper, and alias are separate symbols. Query every relevant symbol separately. When starting from an accessor or wrapper, read its implementation, resolve the backing field, delegate, or trait item with LSP, then query those symbols too. Never use one symbol's references as proof of a complete semantic class.
 4. If an initial workspace-symbol request is empty or reports indexing, wait and retry; startup or indexing time does not permit replacing a required semantic query with text matching. Retry the same bounded workspace query at most two more times. If it still cannot resolve, record the operation and result as unresolved.
 5. Read the complete project-owned callable unit at every resolved location.

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

@@ -12,6 +12,11 @@ planning-session memory candidate and provides an exact path.
 - If VCM did not provide a path, do not create a proposal.
 - Propose only verified, durable, reusable project knowledge supported by task
   evidence.
+- Before proposing an add or update, check current durable documents, Harness
+  rules and skills, and the tool's help, usage, or error output. Cite the checked
+  source in Evidence. Do not duplicate existing knowledge in memory; propose
+  \`durable-doc\` only when the existing document is wrong or incomplete, or use
+  \`memory-reference\` when roles need a short pointer across tasks.
 - Target shared project knowledge to \`shared\`. Target knowledge used only by
   the current role to \`current-role\`.
 - For every add or update, explain why the memory is necessary, what future