@principles/workbuddy-adapter 0.5.0 → 0.5.2

package/dist/pd-hook.js

@@ -280,8 +280,9 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
                 typeof prompt === 'string' && !explicitReserved) {
                 // AUDIT-P3-01: 预检与 admitTrustedWorkbuddyLiveCorrection 内部使用同一份
                 // 共享 live 词库（seed ∪ learned）——预检不会漏掉学习词，也不会比准入
-                // 更宽。startsWith 预过滤保持（SPEC P-5）；歧义候选只落 pending，
-                // 同步 hook 内零 LLM。
+                // 更宽。P-5 退役后不再做句首 startsWith 预过滤，位置安全交给共享守卫
+                // （引号 / 第三人称 / 否定 / 条件语境）；歧义候选只落候选，同步 hook
+                // 内零 LLM。
                 const matched = assessWorkbuddyCorrectionCandidate(prompt, event.context.sessionId, resolveSharedCorrectionKeywordStoreForDetection(resolution.workspaceDir));
                 if (matched.kind !== 'none') {
                     const admitted = admitTrustedWorkbuddyLiveCorrection({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/workbuddy-adapter",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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": "^3.0.0",
-    "@principles/host-runtime": "^1.0.0",
+    "@principles/core": "^4.0.1",
+    "@principles/host-runtime": "^2.0.1",
     "@principles/install-layout": "^0.4.1"
   },
   "devDependencies": {
@@ -61,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "94d353a428b6fc27dd41ff63b767bf915b9ed147"
+  "gitHead": "d9bbe994104eac08a8a41fa1c9374f28dc629aec"
 }

package/plugin/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
   "version": "0.2.2",
-  "description": "Principles Disciple — Owner-governed behavior internalization for AI agents (WorkBuddy host adapter, ADR-0020 third host). Requires explicit setup and host.workbuddy feature enablement; inactive until then. Ships the read-only pd-recall MCP server (Gate 4).",
+  "description": "Principles Disciple — Owner-governed behavior internalization for AI agents (WorkBuddy host adapter, ADR-0020 third host). Three independent states: (1) the PD installer registers this plugin AND sets enabledPlugins=true, so installed means enabled; (2) governance is ON by default at install (features.host.workbuddy.enabled=true) and an explicit false opt-out is preserved; (3) automatic pain detection/correction is NOT available in WorkBuddy — record pain only with the explicit \"PD记录痛苦：\" prefix. The manifest defaultEnabled=false applies only when a host installs this plugin WITHOUT the PD installer. Ships the read-only pd-recall MCP server (Gate 4).",
   "defaultEnabled": false
 }

package/plugin/mcp/launcher.cjs

@@ -36,6 +36,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { pathToFileURL } = require('url');
+const crypto = require('crypto');
 
 const BINDING_SCHEMA = 'pd.mcp-binding.v1';
 // Ownership stamp (SPEC §7.5/§11.3): installers and `pd health` prove that a
@@ -60,7 +61,200 @@ const SERVER_ENTRY_SEGMENTS = {
 const SERVER_PACKAGE_NAME = '@principles/pd-mcp-server';
 const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 
+// ── Durable observability log (default ON, PD_MCP_LOG=0 disables) ──────────
+// Same file contract as the server: ~/.pd/logs/mcp, one JSONL file per
+// process, 2 MiB/file, 64 MiB/dir, 14 days retention. The launcher writes
+// `launcher_start` / `startup_failure` and then hands the SAME file to the
+// server through PD_MCP_LOG_FILE (basename only) so a process keeps one file.
+// Everything here is best-effort: a logging failure never changes the
+// fail-closed decision or the stderr line the host parses.
+const LAUNCHER_VERSION = 'pd-mcp-launcher.v1';
+const LOG_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const LOG_MAX_DIR_BYTES = 64 * 1024 * 1024;
+const LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+const LOG_MAX_SHARDS = 3;
+const LOG_DISABLED = ['0', 'false', 'off'].includes(String(process.env.PD_MCP_LOG || '').trim().toLowerCase());
+const INITIAL_ENV_PRESENCE = Object.freeze({
+  PD_MCP_WORKSPACE_DIR: typeof process.env.PD_MCP_WORKSPACE_DIR === 'string' && process.env.PD_MCP_WORKSPACE_DIR.length > 0,
+  PD_MCP_HOST: typeof process.env.PD_MCP_HOST === 'string' && process.env.PD_MCP_HOST.length > 0,
+  PD_WORKSPACE_DIR: typeof process.env.PD_WORKSPACE_DIR === 'string' && process.env.PD_WORKSPACE_DIR.length > 0,
+  OPENCLAW_WORKSPACE: typeof process.env.OPENCLAW_WORKSPACE === 'string' && process.env.OPENCLAW_WORKSPACE.length > 0,
+});
+
+const logState = {
+  host: 'unknown',
+  bindingPathExists: false,
+  workspaceResolution: 'not_checked',
+  seq: 0,
+  runId: null,
+  fileName: null,
+  currentPath: null,
+  bytes: 0,
+  shard: 1,
+  exhausted: false,
+};
+
+function pad(value, width) {
+  return String(value).padStart(width || 2, '0');
+}
+
+function localTimestamp(date) {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? '+' : '-';
+  const abs = Math.abs(offsetMinutes);
+  return {
+    ts:
+      `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+      `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}` +
+      `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`,
+    tzOffsetMinutes: offsetMinutes,
+  };
+}
+
+function logDir() {
+  const override = process.env.PD_MCP_LOG_DIR;
+  if (typeof override === 'string' && override.trim().length > 0) return path.resolve(override);
+  return path.join(os.homedir(), '.pd', 'logs', 'mcp');
+}
+
+function sanitizeSegment(value) {
+  const cleaned = String(value).replace(/[^A-Za-z0-9_-]/g, '').slice(0, 40);
+  return cleaned.length > 0 ? cleaned : 'unknown';
+}
+
+function listOwnLogFiles(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && /^mcp-.*\.jsonl$/.test(entry.name))
+      .map((entry) => {
+        const fullPath = path.join(dir, entry.name);
+        try {
+          const stat = fs.statSync(fullPath);
+          return { fullPath, size: stat.size, mtimeMs: stat.mtimeMs };
+        } catch {
+          return null;
+        }
+      })
+      .filter((file) => file !== null);
+  } catch {
+    return [];
+  }
+}
+
+function maintainLogDir(dir, nowMs, keepPath) {
+  try {
+    const survivors = [];
+    for (const file of listOwnLogFiles(dir)) {
+      if (nowMs - file.mtimeMs > LOG_RETENTION_MS && file.fullPath !== keepPath) {
+        try {
+          fs.unlinkSync(file.fullPath);
+          continue;
+        } catch {
+          // Keep it.
+        }
+      }
+      survivors.push(file);
+    }
+    let total = survivors.reduce((sum, file) => sum + file.size, 0);
+    if (total <= LOG_MAX_DIR_BYTES) return;
+    for (const file of survivors.filter((f) => f.fullPath !== keepPath).sort((a, b) => a.mtimeMs - b.mtimeMs)) {
+      if (total <= LOG_MAX_DIR_BYTES) break;
+      try {
+        fs.unlinkSync(file.fullPath);
+        total -= file.size;
+      } catch {
+        // Leave it.
+      }
+    }
+  } catch {
+    // Maintenance is advisory only.
+  }
+}
+
+function ensureLogFile() {
+  if (LOG_DISABLED) return null;
+  if (logState.currentPath !== null) return logState.currentPath;
+  try {
+    const dir = logDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (!fs.statSync(dir).isDirectory()) return null;
+    maintainLogDir(dir, Date.now(), null);
+    const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+    logState.fileName = `mcp-${sanitizeSegment(logState.host)}-${process.pid}-${stamp}.jsonl`;
+    logState.runId = crypto.randomBytes(4).toString('hex');
+    logState.currentPath = path.join(dir, logState.fileName);
+    try {
+      logState.bytes = fs.statSync(logState.currentPath).size;
+    } catch {
+      logState.bytes = 0;
+    }
+    return logState.currentPath;
+  } catch {
+    return null;
+  }
+}
+
+function writeLogEvent(level, event, fields) {
+  try {
+    const file = ensureLogFile();
+    if (file === null) return;
+    const dir = path.dirname(file);
+    const stamp = localTimestamp(new Date());
+    const entry = Object.assign(
+      {
+        ts: stamp.ts,
+        tzOffsetMinutes: stamp.tzOffsetMinutes,
+        runId: logState.runId,
+        seq: (logState.seq += 1),
+        server: 'pd-mcp-launcher',
+        version: LAUNCHER_VERSION,
+        level,
+        event,
+        host: logState.host,
+        pid: process.pid,
+      },
+      fields
+    );
+    const line = JSON.stringify(entry) + '\n';
+    const bytes = Buffer.byteLength(line, 'utf8');
+    if (logState.exhausted || logState.bytes + bytes > LOG_MAX_FILE_BYTES) {
+      if (logState.shard >= LOG_MAX_SHARDS) {
+        logState.exhausted = true;
+        return;
+      }
+      logState.shard += 1;
+      logState.currentPath = path.join(dir, logState.fileName.replace(/\.jsonl$/, `-${logState.shard}.jsonl`));
+      logState.bytes = 0;
+      maintainLogDir(dir, Date.now(), logState.currentPath);
+    }
+    fs.appendFileSync(logState.currentPath, line, { mode: 0o600 });
+    logState.bytes += bytes;
+  } catch {
+    // Logging must never affect launch behaviour.
+  }
+}
+
+/** Hand the same file/runId/seq to the server so one process keeps one file. */
+function shareLogFileWithServer() {
+  try {
+    if (logState.fileName === null) ensureLogFile();
+    if (logState.fileName === null) return;
+    process.env.PD_MCP_LOG_FILE = path.basename(logState.fileName);
+    process.env.PD_MCP_LOG_RUN_ID = logState.runId;
+    process.env.PD_MCP_LOG_SEQ = String(logState.seq);
+  } catch {
+    // The server then opens its own file — still bounded, still silent.
+  }
+}
+
 function fail(reason, nextAction) {
+  writeLogEvent('error', 'startup_failure', {
+    stage: 'launcher',
+    reason: String(reason).replace(/[^A-Za-z0-9_.:-]/g, '').slice(0, 120),
+    bindingPathExists: logState.bindingPathExists,
+    workspaceResolution: logState.workspaceResolution,
+    envPresence: INITIAL_ENV_PRESENCE,
+  });
   process.stderr.write(JSON.stringify({ launcher: 'pd-mcp', status: 'failed', reason, nextAction }) + '\n');
   process.exit(1);
 }
@@ -179,12 +373,19 @@ if (detectedHosts.length !== 1) {
   );
 }
 const host = detectedHosts[0];
+logState.host = host;
 
 // rc-1/rc-3/rc-5: the binding file is read as untrusted; every field is
 // validated before use and unknown content is never coerced.
+const bindingPath = path.join(pluginRoot, 'mcp-binding.json');
+try {
+  logState.bindingPathExists = fs.statSync(bindingPath).isFile();
+} catch {
+  logState.bindingPathExists = false;
+}
 let raw;
 try {
-  raw = fs.readFileSync(path.join(pluginRoot, 'mcp-binding.json'), 'utf8');
+  raw = fs.readFileSync(bindingPath, 'utf8');
 } catch {
   fail('binding_missing', 'Re-run the PD host setup (Codex: $pd-control setup) so mcp-binding.json is written into the plugin directory.');
 }
@@ -294,6 +495,7 @@ try {
 if (!workspaceStat.isDirectory()) {
   fail('binding_workspace_not_directory', 'Re-run the PD host setup so the binding points at the governance workspace directory.');
 }
+logState.workspaceResolution = 'ok';
 
 // ── OpenClaw workspace-declaration gate (SPEC §3.5, final safety closure) ──
 // The OpenClaw binding is HOST-WIDE while agents have per-agent workspaces, so
@@ -328,6 +530,18 @@ if (host === 'openclaw') {
 process.env.PD_MCP_WORKSPACE_DIR = binding.workspaceDir;
 process.env.PD_MCP_HOST = host;
 
+// Validation is complete: record the launch attempt (version, binding
+// presence, workspace resolution and env PRESENCE — never values) and then
+// share this file with the server.
+writeLogEvent('info', 'launcher_start', {
+  launcherVersion: LAUNCHER_VERSION,
+  mcpServerVersion: packageManifest.version,
+  bindingPathExists: logState.bindingPathExists,
+  workspaceResolution: logState.workspaceResolution,
+  envPresence: INITIAL_ENV_PRESENCE,
+});
+shareLogFileWithServer();
+
 // Run the shared server entry in-process (single process per host). Nothing
 // above imports the server, so a rejected binding never emits MCP traffic.
 import(pathToFileURL(realEntry).href)

package/plugin/skills/pd-pain-signal/SKILL.md

@@ -5,6 +5,10 @@ description: 当 Owner 要求记录 WorkBuddy 智能体的行为错误、痛苦
 
 # PD Pain Signal（WorkBuddy）
 
+WorkBuddy **没有自动识别/自动纠正通道**：宿主侧缺少持久化的观测证据写入方，
+自动关键词候选只会被标记为 `observation_only`，不会写入痛苦数据库。因此不要
+声称、暗示或期待自动检测生效；唯一入口就是下面的显式标记。
+
 ## 唯一的正常入口
 
 Owner 在当前 WorkBuddy 会话中提交：