@principles/host-runtime 0.8.2 → 0.9.1

package/dist/prompt-injection-projection.js

@@ -3,24 +3,32 @@ import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
 import { buildActivePrinciplePromptContext, readPromptActivationCandidates, MAX_SHARED_DIAGNOSTIC_IDS } from './active-principle-prompt.js';
 import { readWorkspaceHostKindFacts } from './host-liveness-contract.js';
-export const PROMPT_INJECTION_TARGET_HOSTS = ['openclaw', 'codex'];
+/** Single host roster (review P2): every consumer derives from this list, so a
+ * new host cannot fork route-unconfirmed per-host forecasts from the routes. */
+export const PROMPT_INJECTION_TARGET_HOSTS = ['openclaw', 'codex', 'workbuddy'];
+/** Runtime membership test derived from the roster (rc-2): the ONE guard for
+ * "is this untrusted host-kind string a host with a known prompt-injection
+ * route". Every consumer narrows with this — never by re-typing the literals
+ * (review R1: each re-typed list forked the roster and dropped WorkBuddy). */
+export function isPromptInjectionTargetHost(kind) {
+    return typeof kind === 'string' && PROMPT_INJECTION_TARGET_HOSTS.includes(kind);
+}
 export const PROMPT_INJECTION_UNIT = 'utf16_code_units';
 /**
  * THE one route formula (P4): Codex always injects through the shared route
- * (codex-adapter has no flag branch); OpenClaw routes by its
- * `abstraction_layer_v1` gate. Every consumer that needs "which route would
- * host X take" must call this — never re-type the ternary.
+ * (codex-adapter has no flag branch); so does WorkBuddy (workbuddy-adapter
+ * renders through the shared runtime unconditionally — it has no legacy
+ * route); OpenClaw routes by its `abstraction_layer_v1` gate. Every consumer
+ * that needs "which route would host X take" must call this — never re-type
+ * the ternary.
  */
 export function promptRouteForHost(hostKind, flagEnabled) {
-    if (hostKind === 'codex')
+    if (hostKind === 'codex' || hostKind === 'workbuddy')
         return 'shared_render';
     return flagEnabled ? 'shared_render' : 'legacy_trim';
 }
 function standardHostRoutes(flagEnabled) {
-    return [
-        { hostKind: 'openclaw', route: promptRouteForHost('openclaw', flagEnabled) },
-        { hostKind: 'codex', route: promptRouteForHost('codex', flagEnabled) },
-    ];
+    return PROMPT_INJECTION_TARGET_HOSTS.map((hostKind) => ({ hostKind, route: promptRouteForHost(hostKind, flagEnabled) }));
 }
 /**
  * Resolve the effective route for this workspace. Pure read of existing
@@ -83,8 +91,8 @@ export function resolvePromptInjectionRouteDecision(input) {
             perHost: standardHostRoutes(flagEnabled),
         };
     }
-    const knownKinds = facts.effectiveKinds.filter((kind) => kind === 'openclaw' || kind === 'codex');
-    const unknownKinds = facts.effectiveKinds.filter((kind) => kind !== 'openclaw' && kind !== 'codex');
+    const knownKinds = facts.effectiveKinds.filter(isPromptInjectionTargetHost);
+    const unknownKinds = facts.effectiveKinds.filter((kind) => !isPromptInjectionTargetHost(kind));
     if (unknownKinds.length > 0) {
         return {
             status: 'unconfirmed',
@@ -92,7 +100,7 @@ export function resolvePromptInjectionRouteDecision(input) {
             declaredHostKinds: facts.declaredKinds,
             effectiveHostKinds: facts.effectiveKinds,
             unconfirmedReason: `unknown_host_kind_declared: ${unknownKinds.join(', ')} has no known prompt-injection route`,
-            nextAction: 'pass an explicit target host (openclaw|codex) for this request, or remove the unknown host declaration',
+            nextAction: 'pass an explicit target host (openclaw|codex|workbuddy) for this request, or remove the unknown host declaration',
             perHost: standardHostRoutes(flagEnabled),
         };
     }
@@ -117,7 +125,7 @@ export function resolvePromptInjectionRouteDecision(input) {
             declaredHostKinds: facts.declaredKinds,
             effectiveHostKinds: facts.effectiveKinds,
             unconfirmedReason: 'no_host_facts_and_flag_off: no host declaration or host evidence exists, and the applicable hosts would take different routes',
-            nextAction: 'pass an explicit target host (openclaw|codex), or let a host run once in this workspace so it persists its declaration',
+            nextAction: 'pass an explicit target host (openclaw|codex|workbuddy), or let a host run once in this workspace so it persists its declaration',
             perHost: standardHostRoutes(flagEnabled),
         };
     }
@@ -151,8 +159,8 @@ export function resolvePromptInjectionRouteDecision(input) {
         flagEnabled,
         declaredHostKinds: facts.declaredKinds,
         effectiveHostKinds: facts.effectiveKinds,
-        unconfirmedReason: 'multi_host_routes_differ: openclaw would take the legacy list route and codex the shared route under the current flag-off config',
-        nextAction: 'pass an explicit target host (openclaw|codex) for this request, or enable abstraction_layer_v1 so both hosts share one route',
+        unconfirmedReason: 'multi_host_routes_differ: openclaw would take the legacy list route while codex/workbuddy would take the shared route under the current flag-off config',
+        nextAction: 'pass an explicit target host (openclaw|codex|workbuddy) for this request, or enable abstraction_layer_v1 so all hosts share one route',
         perHost: standardHostRoutes(flagEnabled),
     };
 }
@@ -216,7 +224,13 @@ function isDiagnosticCapHit(ids) {
  */
 export async function buildLivePromptInjectionProjection(input) {
     const flagEnabled = computeFeatureFlagsFromConfig(loadPdConfigForPlugin(input.workspaceDir).effective).flags.abstraction_layer_v1?.enabled === true;
-    const sharedRoute = input.targetHost === 'codex' ? true : flagEnabled;
+    // Route face follows THE one route formula (review P2-2: a re-typed
+    // codex-only ternary forecast WorkBuddy as legacy_trim while its adapter
+    // renders shared unconditionally). No explicit target (console callers)
+    // keeps the flag-gated workspace default.
+    const sharedRoute = input.targetHost === undefined
+        ? flagEnabled
+        : promptRouteForHost(input.targetHost, flagEnabled) === 'shared_render';
     if (sharedRoute) {
         const context = await buildActivePrinciplePromptContext(input);
         const oversized = context.oversizedActivationIds ?? [];

package/dist/workbuddy-worker-status.d.ts

@@ -0,0 +1,24 @@
+/**
+ * WorkBuddy worker status-mode semantics — host-runtime authority (mirrors
+ * the Codex Slice D placement): the CLI worker --status and any health
+ * surface share ONE mode evaluation, which only depends on host-neutral
+ * inputs (governance workspace directory, .pd/config.yaml flags, install
+ * manifest registration). The WorkBuddy evaluation has NO ingestion step to
+ * gate — the hook is the only evidence producer in the WorkBuddy MVP
+ * (SPEC workbuddy-host-adapter §1 Excluded: no transcript reads).
+ *
+ * SPEC §15 worker mode, evaluated WITHOUT executing anything (no lease, no
+ * LLM). `manual_action_required` means no Companion-registered worker serves
+ * this governance workspace — manual `pd diagnose` / `pd runtime
+ * internalization run-once` is the recovery route.
+ */
+export type WorkbuddyWorkerMode = 'ready' | 'manual_action_required' | 'paused' | 'degraded';
+export interface WorkbuddyWorkerStatusEvaluation {
+    readonly mode: WorkbuddyWorkerMode;
+    readonly reason?: string;
+    readonly nextAction?: string;
+}
+export declare function computeWorkbuddyWorkerStatusMode(input: {
+    workspaceDir: string;
+    registeredInInstallManifest: boolean;
+}): WorkbuddyWorkerStatusEvaluation;

package/dist/workbuddy-worker-status.js

@@ -0,0 +1,52 @@
+/**
+ * WorkBuddy worker status-mode semantics — host-runtime authority (mirrors
+ * the Codex Slice D placement): the CLI worker --status and any health
+ * surface share ONE mode evaluation, which only depends on host-neutral
+ * inputs (governance workspace directory, .pd/config.yaml flags, install
+ * manifest registration). The WorkBuddy evaluation has NO ingestion step to
+ * gate — the hook is the only evidence producer in the WorkBuddy MVP
+ * (SPEC workbuddy-host-adapter §1 Excluded: no transcript reads).
+ *
+ * SPEC §15 worker mode, evaluated WITHOUT executing anything (no lease, no
+ * LLM). `manual_action_required` means no Companion-registered worker serves
+ * this governance workspace — manual `pd diagnose` / `pd runtime
+ * internalization run-once` is the recovery route.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadPdConfigForPlugin } from './pd-config.js';
+import { computeFeatureFlagsFromConfig } from '@principles/core/runtime-v2';
+function directoryExists(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function computeWorkbuddyWorkerStatusMode(input) {
+    const workspaceDir = path.resolve(input.workspaceDir);
+    if (!directoryExists(workspaceDir)) {
+        return { mode: 'degraded', reason: 'workspace_missing', nextAction: 'The governance workspace directory does not exist; run the WorkBuddy setup flow to initialize it.' };
+    }
+    const config = loadPdConfigForPlugin(workspaceDir);
+    if (!config.ok) {
+        const [first] = config.errors;
+        return { mode: 'degraded', reason: `pd_config_invalid:${first?.reason ?? 'unknown'}`, nextAction: first?.nextAction ?? 'Repair the governance workspace .pd/config.yaml.' };
+    }
+    const { flags } = computeFeatureFlagsFromConfig(config.effective);
+    if (flags['host.workbuddy']?.enabled !== true) {
+        return { 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.' };
+    }
+    if (flags.internalization_auto_consumer?.enabled !== true) {
+        return { mode: 'paused', reason: 'internalization_auto_consumer_disabled', nextAction: 'Automatic execution is paused; manual commands remain available: pd diagnose, pd runtime internalization run-once.' };
+    }
+    if (!input.registeredInInstallManifest) {
+        return {
+            mode: 'manual_action_required',
+            reason: 'workspace_not_in_install_manifest',
+            nextAction: `No Companion worker is registered for this governance workspace. Manual path: pd diagnose --workspace "${workspaceDir}", then pd runtime internalization run-once.`,
+        };
+    }
+    return { mode: 'ready' };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "description": "Shared host-neutral orchestration for Principles Disciple MVP-Core hook paths.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,9 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE",
+    "NOTICE"
   ],
   "scripts": {
     "build": "tsc",
@@ -21,22 +23,22 @@
     "lint": "eslint \"src/**/*.ts\""
   },
   "dependencies": {
-    "@principles/core": "^1.291.3",
-    "@principles/install-layout": "^0.2.7",
+    "@principles/core": "^1.292.1",
+    "@principles/install-layout": "^0.3.1",
     "better-sqlite3": "^13.0.3",
-    "js-yaml": "^5.4.1"
+    "js-yaml": "^5.4.3"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^26.4.1",
     "@types/js-yaml": "^4.0.9",
     "typescript": "^7.0.2",
-    "vite": "^8.3.0",
+    "vite": "^8.3.4",
     "vitest": "^5.0.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/csuzngjh/principles.git"
   },
-  "license": "MIT"
+  "license": "Apache-2.0"
 }