@principles/workbuddy-adapter 0.2.14 → 0.2.16

package/dist/codec/input-decoder.d.ts

@@ -13,18 +13,21 @@ export declare class WorkBuddyDecoderError extends Error {
  * SPEC §4.2 failure normalization: WorkBuddy marks tool failure through
  * explicit shapes — `{is_error:true,...}` (Read failures), Bash
  * `{exitCode>0, error}` — while SUCCESS may be a bare STRING (rendered Read
- * output). A string carries no failure marker and is passed through
- * faithfully (the frozen fixtures show string === Read success; asserting
- * success-or-failure from string-ness alone would be fabrication).
+ * output).
  *
- * The shared production pain path (production-pain-evidence normalizeOutcome)
- * detects failure from an `error` field or a non-zero `exitCode` on the
- * envelope/result. `{is_error:true}` WITHOUT either (the read-iserror fixture
- * shape) would silently classify as success there — so this decoder wraps
- * every DETECTED failure in an explicit envelope
- * `{result: <original>, error: <explicit>}`, preserving the raw response
- * inside `result` while guaranteeing the failure is never missed. Missing
- * exitCode on a detected failure NEVER defaults to success.
+ * SPEC-RULECODE-HOST-PROMOTION-001 R2: on the PostToolUse channel the FROZEN
+ * host contract (Phase 0 baseline; see the channel table at the top of this
+ * file) is itself completion evidence — PostToolUseFailure is a SEPARATE
+ * registration and "PostToolUse never fires for that failure class". A
+ * response with NO failure marker on THIS channel is therefore a completed
+ * success, not an unconfirmed shape: the durable tool_calls row must record
+ * `success` so the WorkBuddy rule-context provider can assemble a real
+ * history window (an `unknown` row is rejected by the shared history
+ * validator, which would leave the provider permanently unavailable on this
+ * host). String-ness ALONE still proves nothing on any other channel — the
+ * classification rides on the channel contract, and every DETECTED failure
+ * is still wrapped `{result, error}` so the shared classifier can never
+ * miss it. Missing exitCode on a detected failure NEVER defaults to success.
  */
 export declare function normalizeWorkbuddyToolResponse(toolResponse: unknown, eventForDiagnostics: string): unknown;
 export declare function decodeWorkbuddyInput(raw: unknown): HostEvent;

package/dist/codec/input-decoder.js

@@ -127,22 +127,33 @@ function field(value, key) {
  * SPEC §4.2 failure normalization: WorkBuddy marks tool failure through
  * explicit shapes — `{is_error:true,...}` (Read failures), Bash
  * `{exitCode>0, error}` — while SUCCESS may be a bare STRING (rendered Read
- * output). A string carries no failure marker and is passed through
- * faithfully (the frozen fixtures show string === Read success; asserting
- * success-or-failure from string-ness alone would be fabrication).
+ * output).
  *
- * The shared production pain path (production-pain-evidence normalizeOutcome)
- * detects failure from an `error` field or a non-zero `exitCode` on the
- * envelope/result. `{is_error:true}` WITHOUT either (the read-iserror fixture
- * shape) would silently classify as success there — so this decoder wraps
- * every DETECTED failure in an explicit envelope
- * `{result: <original>, error: <explicit>}`, preserving the raw response
- * inside `result` while guaranteeing the failure is never missed. Missing
- * exitCode on a detected failure NEVER defaults to success.
+ * SPEC-RULECODE-HOST-PROMOTION-001 R2: on the PostToolUse channel the FROZEN
+ * host contract (Phase 0 baseline; see the channel table at the top of this
+ * file) is itself completion evidence — PostToolUseFailure is a SEPARATE
+ * registration and "PostToolUse never fires for that failure class". A
+ * response with NO failure marker on THIS channel is therefore a completed
+ * success, not an unconfirmed shape: the durable tool_calls row must record
+ * `success` so the WorkBuddy rule-context provider can assemble a real
+ * history window (an `unknown` row is rejected by the shared history
+ * validator, which would leave the provider permanently unavailable on this
+ * host). String-ness ALONE still proves nothing on any other channel — the
+ * classification rides on the channel contract, and every DETECTED failure
+ * is still wrapped `{result, error}` so the shared classifier can never
+ * miss it. Missing exitCode on a detected failure NEVER defaults to success.
  */
 export function normalizeWorkbuddyToolResponse(toolResponse, eventForDiagnostics) {
-    if (typeof toolResponse === 'string')
-        return toolResponse;
+    if (typeof toolResponse === 'string') {
+        // Wrap under a NON-`result` key: the shared classifier treats a record
+        // envelope as a structured completion, but a string inside `result` would
+        // still hit its text-only → unknown branch. `toolResponse` preserves the
+        // rendered text verbatim while the envelope carries the channel-contract
+        // completion.
+        return eventForDiagnostics === 'PostToolUse'
+            ? { toolResponse }
+            : toolResponse;
+    }
     if (!isRecord(toolResponse)) {
         throw new WorkBuddyDecoderError(`malformed required field "tool_response"`, `${eventForDiagnostics} tool_response must be the rendered string or the engine result object from ${HOST_CONTRACT_BASELINE}.`);
     }
@@ -152,8 +163,11 @@ export function normalizeWorkbuddyToolResponse(toolResponse, eventForDiagnostics
     const errorValue = field(toolResponse, 'error');
     const errorText = typeof errorValue === 'string' && errorValue.trim().length > 0 ? errorValue : undefined;
     const failed = isError || (exitCode !== undefined && exitCode > 0) || errorText !== undefined;
-    if (!failed)
+    if (!failed) {
+        // An object envelope is already a structured completion for the shared
+        // classifier (normalizeOutcome: record ⇒ success) — pass through.
         return toolResponse;
+    }
     const toolErrorCode = field(toolResponse, 'tool_error_code');
     let explicitError;
     if (errorText !== undefined) {

package/dist/pd-hook.js

@@ -37,7 +37,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { appendEventLogLine, redactTelemetryString, isRuleHostEvaluatedEventData } from '@principles/core/runtime-v2';
-import { createProductionHostRuntime, loadPdConfigForPlugin, parseOwnerStatementPrefix, assessWorkbuddyLiveKeyword, resolveSharedCorrectionKeywordStoreForDetection, admitTrustedWorkbuddyLiveCorrection, ensureGovernanceDiagnosticianTask } from '@principles/host-runtime';
+import { createProductionHostRuntime, createWorkbuddyRuleContextProvider, loadPdConfigForPlugin, parseOwnerStatementPrefix, assessWorkbuddyLiveKeyword, resolveSharedCorrectionKeywordStoreForDetection, admitTrustedWorkbuddyLiveCorrection, ensureGovernanceDiagnosticianTask } from '@principles/host-runtime';
 import { computeFeatureFlagsFromConfig } from '@principles/core/runtime-v2';
 import { WorkBuddyHooksHostAdapter } from './host-adapter.js';
 import { WORKBUDDY_TOOL_SEMANTICS } from './tool-semantics.js';
@@ -157,16 +157,16 @@ function recordRuleHostEvaluations(stateDir, sessionId, evaluations) {
     return diagnostics;
 }
 /**
- * PRI-780 pattern (WorkBuddy boundary, same as Codex): this host supplies no
- * runtime context provider, and the "unavailable → allow" contract is prompt
- * discipline, NOT a runtime-enforced invariant. Handing v2 rules a truthy
- * context would let a persisted rule evaluate context-blind and deny calls
- * that were previously suspended — a silent governance change. The gate skips
- * v2 rules with its structured `rule_context_v2_unavailable` warning and this
- * hook annotates the warning with the explicit host-unsupported reason before
- * it reaches stderr (明确 unsupported, never a silent skip).
+ * SPEC-RULECODE-HOST-PROMOTION-001 C: WorkBuddy now supplies a REAL V2 rule
+ * context provider over its own trajectory (see the dispatch wiring below),
+ * so the old blanket "host provides no runtime context provider" note no
+ * longer applies. The remaining honest boundary: rules whose required facts
+ * include design_approval stay suspended on this host (no WorkBuddy
+ * design-gate attestation entry exists), and unavailable history still
+ * suspends context-dependent rules through the shared-gate contract. The
+ * note below annotates exactly that residual state.
  */
-const WORKBUDDY_CONTEXT_UNSUPPORTED_NOTE = 'workbuddy_runtime_context_unsupported: the WorkBuddy host provides no runtime context provider; v2 rules stay suspended on this host';
+const WORKBUDDY_CONTEXT_UNSUPPORTED_NOTE = 'workbuddy_runtime_context_limited: WorkBuddy resolves rule context from its own trajectory only; rules requiring design_approval facts or unavailable history stay suspended on this host';
 export function annotateContextWarnings(warnings) {
     return warnings.map((warning) => warning.startsWith('rule_context_v2_unavailable')
         ? `${warning}; ${WORKBUDDY_CONTEXT_UNSUPPORTED_NOTE}`
@@ -226,6 +226,10 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
         }
         return failure;
     }
+    // Capture the decode boundary before governance or runtime work can consume
+    // time; the rule-context history window must never include rows written
+    // afterwards (same cutoff discipline as the Codex hook epoch).
+    const hookEpoch = new Date();
     // OD-07/P06 governance workspace: explicit, user-level, shared across
     // projects; never auto-created here and never falling back to another host.
     const resolution = resolveWorkbuddyWorkspace(os.homedir());
@@ -243,7 +247,11 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
     const { flags } = computeFeatureFlagsFromConfig(config.effective);
     if (flags['host.workbuddy']?.enabled !== true) {
         // OD-03: default OFF; observable skip, no dispatch, no workspace writes.
-        return neutralWithDiagnostics([diagnostic('skipped', 'host.workbuddy_disabled', 'Set features.host.workbuddy.enabled=true in the WorkBuddy governance workspace config to enable PD for WorkBuddy.')]);
+        // PRI-1063 (review fix): `diagnostic()` collapses every whitespace run,
+        // so the hint is a single-line flow mapping; and since every real config
+        // already has a `features:` block, it must be ADDED to that block rather
+        // than pasted as a second top-level one (that is a duplicate-key error).
+        return neutralWithDiagnostics([diagnostic('skipped', 'host.workbuddy_disabled', 'Enable PD for WorkBuddy in the governance workspace config (~/.workbuddy/pd-workspace/.pd/config.yaml) — in the existing "features:" block set host.workbuddy: {enabled: true} (one flat key, not nested).')]);
     }
     const evidenceEnabled = flags.principle_receipt_ledger?.enabled === true;
     // projectDir = the host cwd (payload cwd; SessionStart carries none);
@@ -352,6 +360,23 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
             hostKind: 'workbuddy',
             toolSemantics: WORKBUDDY_TOOL_SEMANTICS,
             events: workbuddyEventEmitter(stateDir, evidenceContext),
+            // SPEC-RULECODE-HOST-PROMOTION-001 C: the V2 rule context provider over
+            // WorkBuddy's own observable trajectory (same-session tool_calls rows
+            // the shared afterToolCall path records). No designGate fact is
+            // supplied — WorkBuddy has no design-gate attestation entry point, so
+            // design_approval-dependent rules suspend with the precise
+            // `rule_required_fact_unavailable` warning rather than borrowing
+            // another host's declaration. Unavailable history (disabled flag, no
+            // project scope, first session turn) degrades through the shared
+            // suspension contract, observably.
+            ruleContextProvider: createWorkbuddyRuleContextProvider({
+                workspaceDir: resolution.workspaceDir,
+                ...(projectDir !== undefined ? { projectDir } : {}),
+                enabled: flags.rulecode_context_v2?.enabled === true,
+                cutoffAt: hookEpoch,
+                currentToolCallId: event.context.toolCallId ?? '',
+                toolSemantics: WORKBUDDY_TOOL_SEMANTICS,
+            }),
             // Remediation R2 (candidate-level admission): the diagnostician's
             // candidates are admitted ONLY with input evidence (needs_evidence
             // otherwise), and Codex-style transcript promotion does not exist on
@@ -378,8 +403,6 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
                         }],
                 };
             },
-            // PRI-780 boundary: NO context provider — v2 rules stay SUSPENDED on
-            // WorkBuddy (never loaded context-blind). See annotateContextWarnings.
         }).dispatch(event);
         const evaluationDiagnostics = recordRuleHostEvaluations(stateDir, event.context.sessionId, result.metadata?.evaluations);
         // Encode BEFORE recording an attributed deny: a runtime_verified

package/dist/worker/workspace-worker.js

@@ -91,7 +91,8 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
     }
     const { flags } = computeFeatureFlagsFromConfig(config.effective);
     if (flags['host.workbuddy']?.enabled !== true) {
-        return { ...base, mode: 'paused', reason: 'host.workbuddy_disabled', nextAction: 'Set features.host.workbuddy.enabled=true in the governance workspace .pd/config.yaml to enable WorkBuddy PD behavior.' };
+        // PRI-1063 (review fix): single-line flow mapping — see pd-hook.ts.
+        return { ...base, mode: 'paused', reason: 'host.workbuddy_disabled', nextAction: 'Enable WorkBuddy PD behavior in the governance workspace .pd/config.yaml — in the existing "features:" block set host.workbuddy: {enabled: true} (one flat key, not nested).' };
     }
     const consumerFlag = loadFeatureFlagFromConfig(workspaceDir, 'internalization_auto_consumer', { info: (m) => logger.info(m), warn: (m) => logger.warn(m) });
     // The Diagnostician capability gate resolves from the same canonical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/workbuddy-adapter",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "WorkBuddy host adapter for Principles Disciple — implements the HostAdapter interface for WorkBuddy's Git Bash command-hook model (ADR-0020 third host, SPEC workbuddy-host-adapter v0.3.0).",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,8 +42,8 @@
     "lint": "eslint \"src/**/*.ts\""
   },
   "dependencies": {
-    "@principles/core": "^1.297.4",
-    "@principles/host-runtime": "^0.14.1",
+    "@principles/core": "^1.297.5",
+    "@principles/host-runtime": "^0.14.3",
     "@principles/install-layout": "^0.4.0"
   },
   "devDependencies": {