deadbyte-mcp 0.15.22 → 0.15.23

package/scripts/pcb-skill-src-pcb_constraint_gate.py.txt

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+import json, sys
+
+def load(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit("usage: pcb_constraint_gate.py board-probe.json board-contract.json")
+    probe = load(sys.argv[1])
+    contract = load(sys.argv[2])
+    if probe.get("schema") != "deadbyte.kicad-pcb-probe.v1":
+        raise SystemExit("unsupported probe schema")
+
+    checks = []
+    def add(rule, ok, observed, required):
+        checks.append({"rule": rule, "ok": bool(ok), "observed": observed, "required": required})
+
+    if "required_layers" in contract:
+        observed = set(x.get("name") for x in probe.get("layers", []))
+        req = list(contract["required_layers"])
+        add("required_layers", all(x in observed for x in req), sorted(observed), req)
+
+    if "min_copper_layers" in contract:
+        observed = probe.get("copper_layer_count")
+        req = int(contract["min_copper_layers"])
+        add("min_copper_layers", isinstance(observed, int) and observed >= req, observed, req)
+
+    for key, probe_key in [
+        ("min_track_width_mm", "track_width_mm"),
+        ("min_via_diameter_mm", "via_diameter_mm"),
+        ("min_via_drill_mm", "via_drill_mm"),
+    ]:
+        if key in contract:
+            observed = (probe.get(probe_key) or {}).get("min")
+            req = float(contract[key])
+            add(key, observed is not None and float(observed) >= req, observed, req)
+
+    if "required_nets" in contract:
+        observed = set(probe.get("nets", []))
+        req = list(contract["required_nets"])
+        add("required_nets", all(x in observed for x in req), sorted(observed), req)
+
+    for key, count_key in [
+        ("min_footprints", "footprints"),
+        ("min_segments", "segments"),
+        ("min_vias", "vias"),
+        ("min_zones", "zones"),
+    ]:
+        if key in contract:
+            observed = (probe.get("counts") or {}).get(count_key)
+            req = int(contract[key])
+            add(key, isinstance(observed, int) and observed >= req, observed, req)
+
+    allowed = {
+        "required_layers", "min_copper_layers", "min_track_width_mm",
+        "min_via_diameter_mm", "min_via_drill_mm", "required_nets",
+        "min_footprints", "min_segments", "min_vias", "min_zones"
+    }
+    unknown = sorted(set(contract) - allowed)
+    if unknown:
+        checks.append({"rule": "unknown_contract_keys", "ok": False, "observed": unknown, "required": "no unsupported keys"})
+
+    passed = all(x["ok"] for x in checks)
+    out = {
+        "schema": "deadbyte.pcb-constraint-gate.v1",
+        "status": "PASS" if passed else "FAIL",
+        "probe_sha256": probe.get("sha256"),
+        "checks": checks
+    }
+    print(json.dumps(out, indent=2, sort_keys=True))
+    raise SystemExit(0 if passed else 2)
+
+if __name__ == "__main__":
+    main()

package/scripts/pcb-skill-src-power-integrity.md.txt

@@ -0,0 +1,15 @@
+# Power Integrity and Thermal
+
+Power integrity begins with current loops, not capacitor count.
+
+For each regulator trace the input current path, keep the high di/dt input loop compact, bound switch-node copper, place bootstrap/gate-drive parts by topology, protect the feedback sense path, close the output-current loop, and provide a credible thermal path.
+
+For decoupling separate bulk-energy storage from local high-frequency charge. Account for capacitor mounting inductance, vias, planes, and package inductance. Printed capacitance alone does not prove useful impedance at frequency.
+
+For planes and pours verify neck-downs at pads, vias, connectors, and thermal spokes; identify slots caused by keepouts and antipads; preserve return continuity; and check both DC drop and transient current paths.
+
+For sensitive analog control where digital and switching currents return. Do not split ground reflexively. Placement, loop control, filtering, and current-path ownership matter more than labels.
+
+Thermal claims require dissipation, package thermal path, copper geometry, ambient, airflow, and enclosure assumptions. Missing inputs mean thermal margin UNKNOWN.
+
+Bench evidence should include rail voltage, ripple/noise with correct probing, startup sequencing, relevant load transient behavior, and regulator temperature under representative load.

package/scripts/prepare-skill-creator-1.1.1.mjs

@@ -0,0 +1,113 @@
+import { readFile, writeFile, mkdir, rm, cp } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+import { createHash, createPrivateKey, createPublicKey, sign } from "node:crypto";
+import { createSkillPlane } from "../src/skill-plane-r44.mjs";
+
+const ex = promisify(execFile);
+const home = os.homedir();
+const stateDir = path.join(home, ".deadbyte-mcp");
+const skillsRoot = path.join(stateDir, "skills");
+const active = path.join(skillsRoot, "skill-creator");
+const expectedOldManifest = "f34b3953db176c8ae9a5e08e7702b39f12b60b013edcd2f4d63a6268af9ba432";
+const oldEnv = JSON.parse(await readFile(path.join(active, "skill.json"), "utf8"));
+if (oldEnv.manifest_sha256 !== expectedOldManifest) {
+  throw new Error("unexpected active skill-creator manifest: " + oldEnv.manifest_sha256);
+}
+if (oldEnv.body.version !== "1.1.0") throw new Error("expected active skill-creator 1.1.0");
+
+const history = path.join(stateDir, "skill-history", "skill-creator", "1.1.0-" + expectedOldManifest);
+await mkdir(path.dirname(history), {recursive:true});
+try {
+  const prior = JSON.parse(await readFile(path.join(history, "skill.json"), "utf8"));
+  if (prior.manifest_sha256 !== expectedOldManifest) throw new Error("history path collision");
+} catch (e) {
+  if (e.code !== "ENOENT") throw e;
+  await cp(active, history, {recursive:true, errorOnExist:true});
+}
+const archived = JSON.parse(await readFile(path.join(history, "skill.json"), "utf8"));
+if (archived.manifest_sha256 !== expectedOldManifest) throw new Error("archive manifest mismatch");
+
+const stageParent = path.join(stateDir, "skill-staging", "skill-creator-1.1.1");
+const stage = path.join(stageParent, "skill-creator");
+await rm(stageParent, {recursive:true, force:true});
+await mkdir(stageParent, {recursive:true});
+await cp(active, stage, {recursive:true});
+await rm(path.join(stage, "references", "skills_cache.json"), {force:true});
+
+const createPath = path.join(stage, "scripts", "create-skill.mjs");
+const oldCreate = await readFile(createPath, "utf8");
+const oldRegex = "const VERSION=/^[0-9]+\\\\.[0-9]+\\\\.[0-9]+(?:-[A-Za-z0-9.-]+)?$/;";
+const newRegex = "const VERSION=/^[0-9]+\\.[0-9]+\\.[0-9]+(?:-[A-Za-z0-9.-]+)?$/;";
+if (!oldCreate.includes(oldRegex)) throw new Error("expected defective VERSION regex not found");
+if (oldCreate.split(oldRegex).length !== 2) throw new Error("VERSION regex occurrence count != 1");
+await writeFile(createPath, oldCreate.replace(oldRegex, newRegex), "utf8");
+
+const skillPath = path.join(stage, "SKILL.md");
+const oldSkill = await readFile(skillPath, "utf8");
+const versionLine = "version: 1.1.0";
+if (!oldSkill.includes(versionLine) || oldSkill.split(versionLine).length !== 2) {
+  throw new Error("SKILL.md version occurrence count != 1");
+}
+await writeFile(skillPath, oldSkill.replace(versionLine, "version: 1.1.1"), "utf8");
+
+const sha = b => createHash("sha256").update(b).digest("hex");
+const canonical = v => Array.isArray(v) ? v.map(canonical) : v && typeof v === "object"
+  ? Object.fromEntries(Object.keys(v).sort((a,b)=>a.localeCompare(b,"en")).map(k=>[k,canonical(v[k])]))
+  : v;
+
+const body = structuredClone(oldEnv.body);
+body.version = "1.1.1";
+body.skill_md_sha256 = sha(await readFile(skillPath));
+body.provenance = {
+  ...body.provenance,
+  source_revision: "r47.1-semver-regex-repair-2026-09-27"
+};
+for (const resource of body.resources) {
+  resource.sha256 = sha(await readFile(path.join(stage, ...resource.path.split("/"))));
+}
+const bodyBytes = Buffer.from(JSON.stringify(canonical(body)), "utf8");
+const body_sha256 = sha(bodyBytes);
+const priv = createPrivateKey(await readFile(path.join(stateDir, "trust", "ed25519-private.pem")));
+const pub = createPublicKey(priv);
+const keyId = sha(pub.export({type:"spki", format:"der"}));
+const attestation = {
+  algorithm: "ed25519",
+  domain: "DEADBYTE-SKILL-MANIFEST-V1",
+  key_id: keyId,
+  signature_base64: sign(null, Buffer.concat([Buffer.from("DEADBYTE-SKILL-MANIFEST-V1\0", "utf8"), bodyBytes]), priv).toString("base64")
+};
+const unsigned = {body, body_sha256, attestation};
+const envelope = {
+  ...unsigned,
+  manifest_sha256: sha(Buffer.from(JSON.stringify(canonical(unsigned)), "utf8"))
+};
+await writeFile(path.join(stage, "skill.json"), JSON.stringify(envelope, null, 2), "utf8");
+
+const validator = await ex(process.execPath, [path.join(stage, "scripts", "validate-skill.mjs"), stage], {
+  timeout: 30000,
+  maxBuffer: 1024 * 1024
+});
+
+const plane = await createSkillPlane({
+  root: stageParent,
+  verifyKeyPath: path.join(stateDir, "trust", "ed25519-public.pem")
+});
+const loaded = await plane.load({name:"skill-creator"});
+if (!loaded.verified || loaded.version !== "1.1.1") throw new Error("staging Skill Plane verification failed");
+
+console.log(JSON.stringify({
+  status:"STAGED",
+  active_manifest:oldEnv.manifest_sha256,
+  archived_path:history,
+  archived_manifest:archived.manifest_sha256,
+  stage_parent:stageParent,
+  stage_skill:stage,
+  candidate_manifest:envelope.manifest_sha256,
+  candidate_body_sha256:body_sha256,
+  verify_key_id:keyId,
+  validator:validator.stdout.trim(),
+  skill_plane_verified:loaded.verified
+}, null, 2));

package/scripts/test-skill-creator-semver-matrix.mjs

@@ -0,0 +1,30 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+const ex=promisify(execFile);
+const creator=process.argv[2];
+if(!creator) throw new Error("creator path required");
+const valid=["1.0.0","0.0.1","1.1.1","12.34.56","1.0.0-rc.1"];
+const invalid=["1.0","v1.0.0","1.a.0","",String.fromCharCode(49,92,97,48,92,98,48)];
+const results=[];
+for(const version of valid){
+  const tmp=await mkdtemp(path.join(os.tmpdir(),"deadbyte-semver-valid-"));
+  try{
+    await ex(process.execPath,[creator,tmp,"fixture",version],{timeout:30000,maxBuffer:1048576});
+    results.push({version,expected:"PASS",observed:"PASS"});
+  }finally{await rm(tmp,{recursive:true,force:true});}
+}
+for(const version of invalid){
+  const tmp=await mkdtemp(path.join(os.tmpdir(),"deadbyte-semver-invalid-"));
+  let rejected=false;
+  try{
+    await ex(process.execPath,[creator,tmp,"fixture",version],{timeout:30000,maxBuffer:1048576});
+  }catch(e){
+    if(e.code===1 && String(e.stderr).includes("invalid version")) rejected=true;
+  }finally{await rm(tmp,{recursive:true,force:true});}
+  if(!rejected) throw new Error("invalid version accepted: "+JSON.stringify(version));
+  results.push({version,expected:"FAIL",observed:"FAIL"});
+}
+console.log(JSON.stringify({status:"PASS",cases:results},null,2));

package/scripts/test-skill-creator-semver.mjs

@@ -0,0 +1,22 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+
+const ex = promisify(execFile);
+const creator = process.argv[2];
+if (!creator) throw new Error("usage: node test-skill-creator-semver.mjs <create-skill.mjs>");
+const tmp = await mkdtemp(path.join(os.tmpdir(), "deadbyte-skill-creator-semver-"));
+try {
+  const r = await ex(process.execPath, [creator, tmp, "semver-regression-fixture", "1.0.0"], {
+    timeout: 30000,
+    maxBuffer: 1024 * 1024
+  });
+  if (!r.stdout.includes("semver-regression-fixture")) {
+    throw new Error("create-skill returned success without fixture path");
+  }
+  console.log(JSON.stringify({status:"PASS", version:"1.0.0", stdout:r.stdout.trim()}));
+} finally {
+  await rm(tmp, {recursive:true, force:true});
+}

package/src/deadbyte-cli.mjs

@@ -13,7 +13,7 @@ import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-resul
 import { DEADBYTE_VERSION } from './version.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
-import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
+import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 
 const REMOTE_COMMANDS=new Set([
@@ -46,6 +46,8 @@ function printHelp(){
     `  npx -y ${exact} mcp                 # stdio MCP server for local clients`,
     `  npx -y ${exact} remote              # unified foreground device session + live timeline`,
     `  npx -y ${exact} remote --resume <cursor> # replay missed results, then reconnect`,
+    `  npx -y ${exact} remote --trace           # show trace/span identity without payload detail`,
+    `  npx -y ${exact} remote --filter <expr>   # presentation filter: tool/category/status/trace`,
     `  npx -y ${exact} remote status`,
     `  npx -y ${exact} remote restart`,
     `  npx -y ${exact} supervisor status`,
@@ -71,6 +73,21 @@ async function readActiveRuntimeBinding(root){
   try{return parseActivePointer(await readFile(file,'utf8'));}
   catch(error){if(error?.code==='ENOENT') return null;throw new Error(`active runtime pointer invalid: ${boundedSingleLine(error?.message||error,512)}`);}
 }
+async function readLiveRootPaths(root){
+  const active=await readActiveRuntimeBinding(root);
+  if(!active) return Object.freeze({});
+  const file=path.join(active.generation_root,'coding-policy.json');
+  let raw;
+  try{raw=JSON.parse(await readFile(file,'utf8'));}
+  catch(error){if(error?.code==='ENOENT') return Object.freeze({});throw new Error(`live root policy invalid: ${boundedSingleLine(error?.message||error,512)}`);}
+  if(raw?.schema!=='deadbyte.coding-policy.v1'||!raw.roots||typeof raw.roots!=='object'||Array.isArray(raw.roots)) throw new Error('live root policy schema invalid');
+  const roots={};
+  for(const [id,spec] of Object.entries(raw.roots)){
+    if(!/^[A-Za-z0-9._-]{1,64}$/.test(id)||!spec||typeof spec!=='object'||typeof spec.path!=='string'||!path.isAbsolute(spec.path)) continue;
+    roots[id]=path.resolve(spec.path);
+  }
+  return Object.freeze(roots);
+}
 async function reportVersionCoherence(root,{displayMode='ascii'}={}){
   const active=await readActiveRuntimeBinding(root);
   if(!active||active.version===DEADBYTE_VERSION) return active;
@@ -227,7 +244,22 @@ async function snapshotRemoteLogOffsets(root){
   }
   return offsets;
 }
-async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null,verbose=false,displayMode='unicode'}={}){
+function timelineFilterEvent(timeline){
+  if(!timeline) return null;
+  if(timeline.event_type==='tool.call') return {
+    event_type:'tool.request',request_id:timeline.request_id,tool:timeline.tool,args:timeline.arguments??{}
+  };
+  return {
+    event_type:'tool.result',request_id:timeline.request_id,tool:timeline.tool,
+    outcome:{
+      is_error:timeline.status==='error',
+      ...(Number.isFinite(Number(timeline.duration_ms))?{duration_ms:Number(timeline.duration_ms)}:{}),
+      ...(timeline.side_effect_state?{side_effect_state:timeline.side_effect_state}:{}),
+      ...(timeline.reason?{reason:timeline.reason}:{})
+    }
+  };
+}
+async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null,timelineFilter=null,timelineWriter=null,verbose=false,displayMode='unicode'}={}){
   process.stdout.write(verbose
     ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
     : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. Ctrl+C disconnects and revokes authority.\n');
@@ -244,10 +276,14 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
           ? await journal.recordCall(timeline)
           : await journal.recordTerminal(timeline);
         if(recorded?.duplicate) continue;
+        const accepted=timelineFilter&&timeline?timelineFilter.accept(timelineFilterEvent(timeline)):true;
         const formatted=formatLogLine(file,line,{activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
-        if(!formatted) continue;
+        if(!formatted||!accepted) continue;
         const output=Array.isArray(formatted)?formatted:[formatted];
-        for(const item of output) if(item) process.stdout.write(`${item}\n`);
+        for(const item of output) if(item){
+          if(timelineWriter) timelineWriter.write(item,{event_type:timeline?.event_type??null,request_id:timeline?.request_id??null});
+          else process.stdout.write(`${item}\n`);
+        }
       }
     }
     try{await sleep(250,null,{signal});}catch(error){if(error?.name!=='AbortError') throw error;}
@@ -341,7 +377,7 @@ async function releaseRemoteSession(ctx,marker,{displayMode='unicode'}={}){
   const same=current?.schema==='deadbyte.remote-session.v2'&&current.owner_pid===marker.owner_pid&&current.session_nonce===marker.session_nonce;
   if(same) await rm(remoteSessionMarker(ctx.root),{force:true});
 }
-async function runRemoteSession({resumeCursor=null,verbose=false}={}){
+async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,filterExpression=''}={}){
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
@@ -353,7 +389,10 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
-  const activityTracker=createLiveTimelineTracker({verbose,displayMode});
+  const rootPaths=await readLiveRootPaths(ctx.root);
+  const activityTracker=createLiveTimelineTracker({verbose,displayMode,rootPaths,trace});
+  const timelineFilter=filterExpression?createLiveTimelineFilter(filterExpression):null;
+  const timelineWriter=createLiveTimelineWriter({stream:process.stdout,displayMode,rewrite:!verbose});
   const aborter=new AbortController();
   const abort=()=>aborter.abort();
   const watchStdin=!process.stdin.isTTY;
@@ -366,7 +405,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
     process.stdout.write(`${formatRemoteLifecycle('device_start',{displayMode})}\n`);
     process.stdout.write(`${formatRemoteLifecycle(resumeCursor!==null?'session_restored':'session_new',{displayMode})}\n`);
     const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
-    logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker,verbose,displayMode});
+    logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker,timelineFilter,timelineWriter,verbose,displayMode});
     process.stdout.write('[BOOT] Starting local + remote runtime...\n');
     const preflight=invokeController(ctx,'status',{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
     let startText=preflight.stdout||'';
@@ -415,6 +454,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
     const wasAborted=aborter.signal.aborted;
     aborter.abort();
     if(logTask) await logTask.catch(()=>{});
+    timelineWriter.flush();
     for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);
     process.stdout.write(`${activityTracker.summary()}\n`);
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
@@ -426,14 +466,29 @@ async function runRemoteSession({resumeCursor=null,verbose=false}={}){
   }
 }
 async function runRemote(args){
-  if(args.length===0){await runRemoteSession();return;}
-  const verbose=args.includes('--verbose')||args.includes('-v');
-  const filtered=args.filter(arg=>arg!=='--verbose'&&arg!=='-v');
-  if(filtered.length===0){await runRemoteSession({verbose});return;}
-  if(filtered.length===2&&filtered[0]==='--resume'){await runRemoteSession({resumeCursor:filtered[1],verbose});return;}
-  if(verbose) throw new Error('remote --verbose/-v is valid only for foreground session or --resume <cursor>');
-  if(filtered.length>1) throw new Error('remote accepts one controller command or --resume <cursor>');
-  const command=filtered[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
+  let verbose=false,trace=false,filterExpression='',resumeCursor=null;
+  const positional=[];
+  for(let index=0;index<args.length;index++){
+    const arg=args[index];
+    if(arg==='--verbose'||arg==='-v'){verbose=true;continue;}
+    if(arg==='--trace'){trace=true;continue;}
+    if(arg==='--filter'){
+      if(filterExpression) throw new Error('remote --filter may be specified once');
+      if(index+1>=args.length) throw new Error('remote --filter requires an expression');
+      filterExpression=args[++index];continue;
+    }
+    if(arg==='--resume'){
+      if(resumeCursor!==null) throw new Error('remote --resume may be specified once');
+      if(index+1>=args.length) throw new Error('remote --resume requires a cursor');
+      resumeCursor=args[++index];continue;
+    }
+    positional.push(arg);
+  }
+  const presentation=verbose||trace||Boolean(filterExpression)||resumeCursor!==null;
+  if(positional.length===0){await runRemoteSession({resumeCursor,verbose,trace,filterExpression});return;}
+  if(presentation) throw new Error('remote presentation flags are valid only for foreground session');
+  if(positional.length>1) throw new Error('remote accepts one controller command');
+  const command=positional[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
   await reportVersionCoherence(ctx.root,{displayMode:'ascii'});
   const result=invokeController(ctx,command,{allowFailure:true});