portable-agent-layer 0.85.19 → 0.85.21

package/assets/schema/pal-settings.schema.json

@@ -88,11 +88,11 @@
         },
         "claimCheck": {
           "type": "boolean",
-          "description": "At each stop, check whether the final reply claims a result (tests pass, CI green, works now) that no command in that turn could have shown, and log the verdict to memory/signals/claim-checks/. Stores the claiming sentence only when nothing backed it."
+          "description": "At each stop, check whether the final reply claims a result (tests pass, CI green, works now) or a status (not pushed, merged, live) that no command in that turn could have shown, and log the verdict to memory/signals/claim-checks/. A claim about what is committed, pushed, merged or released is backed only by a git or gh command. Stores the claiming sentence only when nothing backed it."
         },
         "claimCheckBlocks": {
           "type": "boolean",
-          "description": "Opt-in, off by default. Send a reply with an unbacked result claim back to the agent once, asking it to show the output or say the result is unverified. Needs claimCheck. Not on Cursor, whose stop payload carries no reply text."
+          "description": "Opt-in, off by default. Send a reply with an unbacked result or status claim back to the agent once, asking it to show the output or say the result is unverified. Needs claimCheck. Not on Cursor, whose stop payload carries no reply text."
         },
         "steeringTestReport": { "type": "boolean", "description": "When true, the assistant notes to the user which steering self-check fired. For the dual-live test period; ships false." }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.85.19",
+  "version": "0.85.21",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/hooks/lib/claim-check.ts

@@ -1,7 +1,8 @@
 /**
- * Whether a reply claims a result (tests pass, CI green, it works now) that no
- * command in the same turn could have shown. Precision over recall: a hedged or
- * negated sentence is never a claim, and an unreadable turn is never unbacked.
+ * Whether a reply claims a result (tests pass, CI green, it works now) or a status
+ * (not pushed, merged, live) that no command in the same turn could have shown.
+ * Precision over recall: a hedged sentence or a question is never a claim, and an
+ * unreadable turn is never unbacked.
  */
 
 import { isSystemText } from "./prompt-text";
@@ -12,6 +13,17 @@ const CLAIM_RE =
 const HEDGED_RE =
   /\b(?:not|no longer|fail(?:s|ed|ing)?|until|when|if|unless|should|would|will|might|could|may)\b|n't\b/i;
 
+const stateClaim = (states: string) =>
+  new RegExp(
+    String.raw`(?:\b(?:is|are|was|were|been|not|yet|still|already|now)|n't|n’t|'s|’s)\s+(?:${states})\b|\bun(?:${states})\b`,
+    "i"
+  );
+const VERSION_CONTROL_CLAIM_RE = stateClaim("committed|pushed|merged|released|tagged");
+const DEPLOY_CLAIM_RE = stateClaim("deployed|live|installed|shipped");
+const STATUS_HEDGED_RE =
+  /\b(?:once|until|when|if|unless|should|would|will|might|could|may)\b/i;
+const READS_VERSION_CONTROL_RE = /\b(?:git|gh)\b/;
+
 const COMMAND_TOOLS = new Set([
   "Bash",
   "BashOutput",
@@ -29,11 +41,12 @@ export interface ClaimCheck {
   claims: string[];
 }
 
-function sentences(reply: string): string[] {
+function statements(reply: string): string[] {
   return reply
     .split(/(?<=[.!?])\s+|\n+/)
-    .map((s) => s.trim().replace(/[.!?]+$/, ""))
-    .filter(Boolean);
+    .map((s) => s.trim())
+    .filter((s) => s && !s.endsWith("?"))
+    .map((s) => s.replace(/[.!]+$/, ""));
 }
 
 /** A quoted claim is being talked about, not made. */
@@ -42,16 +55,47 @@ function withoutQuotes(sentence: string): string {
 }
 
 export function resultClaims(reply: string): string[] {
-  return sentences(reply).filter((s) => {
+  return statements(reply).filter((s) => {
     const own = withoutQuotes(s);
     return CLAIM_RE.test(own) && !HEDGED_RE.test(own);
   });
 }
 
+/** A checklist item states a goal and a line ending in a colon introduces one. */
+function isGoalOrHeading(sentence: string): boolean {
+  return /^[-*]\s*\[[ xX]\]/.test(sentence) || /:\**$/.test(sentence);
+}
+
+function isStatusClaim(sentence: string): boolean {
+  const own = withoutQuotes(sentence);
+  if (isGoalOrHeading(own)) return false;
+  return (
+    (VERSION_CONTROL_CLAIM_RE.test(own) || DEPLOY_CLAIM_RE.test(own)) &&
+    !STATUS_HEDGED_RE.test(own)
+  );
+}
+
+export function statusClaims(reply: string): string[] {
+  return statements(reply).filter(isStatusClaim);
+}
+
+/** What is committed, pushed, merged or released only git can say. */
+export function isVersionControlClaim(claim: string): boolean {
+  return VERSION_CONTROL_CLAIM_RE.test(withoutQuotes(claim));
+}
+
 interface TranscriptLine {
   type?: string;
   message?: { content?: unknown };
-  payload?: { type?: string; role?: string; name?: string; content?: unknown };
+  payload?: {
+    type?: string;
+    role?: string;
+    name?: string;
+    content?: unknown;
+    input?: unknown;
+    arguments?: unknown;
+    action?: unknown;
+  };
 }
 
 function parsed(line: string): TranscriptLine | null {
@@ -62,7 +106,9 @@ function parsed(line: string): TranscriptLine | null {
   }
 }
 
-function blocks(content: unknown): { type?: string; name?: string; text?: string }[] {
+function blocks(
+  content: unknown
+): { type?: string; name?: string; text?: string; input?: unknown }[] {
   return Array.isArray(content) ? content : [];
 }
 
@@ -86,37 +132,51 @@ function isUserPrompt(entry: TranscriptLine): boolean {
   return text !== null && !isSystemText(text) && !isCodexInjectedContext(text);
 }
 
-function commandsIn(entry: TranscriptLine): number {
+const ran = (input: unknown) => JSON.stringify(input ?? {});
+
+function commandsIn(entry: TranscriptLine): string[] {
   if (entry.type === "assistant")
-    return blocks(entry.message?.content).filter(
-      (b) => b.type === "tool_use" && COMMAND_TOOLS.has(b.name ?? "")
-    ).length;
+    return blocks(entry.message?.content)
+      .filter((b) => b.type === "tool_use" && COMMAND_TOOLS.has(b.name ?? ""))
+      .map((b) => ran(b.input));
   const call = entry.payload;
-  if (entry.type !== "response_item" || !call) return 0;
-  if (call.type === "local_shell_call") return 1;
+  if (entry.type !== "response_item" || !call) return [];
+  const input = call.input ?? call.arguments ?? call.action;
+  if (call.type === "local_shell_call") return [ran(input)];
   const isCall = call.type === "function_call" || call.type === "custom_tool_call";
-  return isCall && COMMAND_TOOLS.has(call.name ?? "") ? 1 : 0;
+  return isCall && COMMAND_TOOLS.has(call.name ?? "") ? [ran(input)] : [];
 }
 
 function isTurnEntry(entry: TranscriptLine): boolean {
   return ["user", "assistant", "response_item"].includes(entry.type ?? "");
 }
 
-/** Null when no line reads as a turn, so an unknown transcript format never counts as zero. */
-export function commandsThisTurn(lines: string[]): number | null {
+/** What each command this turn ran. Null when no line reads as a turn, so an
+ *  unknown transcript format never counts as none. */
+export function commandsThisTurn(lines: string[]): string[] | null {
   const entries = lines.map(parsed).filter((e): e is TranscriptLine => e !== null);
   if (!entries.some(isTurnEntry)) return null;
-  let commands = 0;
+  let commands: string[] = [];
   for (const entry of entries) {
-    if (isUserPrompt(entry)) commands = 0;
-    commands += commandsIn(entry);
+    if (isUserPrompt(entry)) commands = [];
+    commands.push(...commandsIn(entry));
   }
   return commands;
 }
 
-export function checkClaims(reply: string, commands: number | null): ClaimCheck {
-  const claims = resultClaims(reply);
+function isBacked(claim: string, commands: string[]): boolean {
+  if (!isVersionControlClaim(claim)) return commands.length > 0;
+  return commands.some((command) => READS_VERSION_CONTROL_RE.test(command));
+}
+
+export function checkClaims(reply: string, commands: string[] | null): ClaimCheck {
+  const claims = statements(reply).filter(
+    (s) => resultClaims(s).length > 0 || isStatusClaim(s)
+  );
   if (claims.length === 0) return { verdict: "none", claims };
   if (commands === null) return { verdict: "unknown", claims };
-  return { verdict: commands > 0 ? "backed" : "unbacked", claims };
+  const unbacked = claims.filter((claim) => !isBacked(claim, commands));
+  return unbacked.length > 0
+    ? { verdict: "unbacked", claims: unbacked }
+    : { verdict: "backed", claims };
 }

package/src/hooks/lib/claim-log.ts

@@ -1,5 +1,5 @@
 /**
- * The claim check at stop: every reply that makes a result claim is logged to
+ * The claim check at stop: every reply that makes a result or status claim is logged to
  * memory/signals/claim-checks/ with its verdict. The claiming sentence is kept
  * only when no command backed it, so the log can be audited. Sending the reply
  * back is opt-in (dynamicContext.claimCheckBlocks).
@@ -13,6 +13,7 @@ import {
   type ClaimVerdict,
   checkClaims,
   commandsThisTurn,
+  isVersionControlClaim,
 } from "./claim-check";
 import { hookFinalReply, hookSessionId } from "./hook-turn";
 import { ensureDir, paths } from "./paths";
@@ -85,11 +86,14 @@ function sendsBack(payload: StopTurnPayload, check: ClaimCheck): boolean {
 
 function sendBackReason(claims: string[]): string {
   const quoted = claims.map((c) => `"${c.slice(0, CLAIM_MAX)}"`).join(", ");
-  return `Your reply claims a result no command in this turn showed: ${quoted}. Run the check and show its output, or say it is unverified.`;
+  const ask = claims.some(isVersionControlClaim)
+    ? "Read what is committed, pushed, merged or released with git or gh and show it"
+    : "Run the check and show its output";
+  return `Your reply claims what no command in this turn showed: ${quoted}. ${ask}, or say it is unverified.`;
 }
 
 /**
- * Checks the final reply against the turn's commands and logs any result claim.
+ * Checks the final reply against the turn's commands and logs any claim.
  * Returns the reason to send the reply back with, when that is opted in.
  */
 export function watchClaims(
@@ -103,7 +107,8 @@ export function watchClaims(
   const check = checkClaims(reply, commands);
   if (check.verdict === "none") return null;
   const blocked = sendsBack(payload, check);
-  record({ check, commands, session: hookSessionId(payload) ?? "unknown", blocked }, now);
+  const session = hookSessionId(payload) ?? "unknown";
+  record({ check, commands: commands?.length ?? null, session, blocked }, now);
   return blocked ? sendBackReason(check.claims) : null;
 }
 

package/src/tools/lib/interaction-report.ts

@@ -208,7 +208,7 @@ export function claimCheckLines(records: ClaimRecord[]): string[] {
   const sentBack = records.filter((r) => r.blocked).length;
   return [
     "",
-    `Result claims: ${plural(records.length, "reply", "replies")} · ${unbacked.length} with no command behind it · ${sentBack} sent back · ${unknown} unreadable`,
+    `Result and status claims: ${plural(records.length, "reply", "replies")} · ${unbacked.length} with no command behind it · ${sentBack} sent back · ${unknown} unreadable`,
     ...unbacked
       .slice(-UNBACKED_LISTED)
       .flatMap((r) => (r.claims ?? []).map((c) => `  no command: ${c}`)),