@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/{chunk-2LZI5CAG.js → chunk-XEGB6BCN.js}

@@ -7,26 +7,31 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-2TZWSW76.js";
+} from "./chunk-WHGPSPT5.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-ZYKPLLNQ.js";
+} from "./chunk-CEYBNUGC.js";
 import {
   taskBoardCounts
-} from "./chunk-WPQLXFOZ.js";
+} from "./chunk-5FR74PWO.js";
 import {
-  SKILL_SUGGESTION_ANCHOR
-} from "./chunk-BEY543CS.js";
+  SKILL_SUGGESTION_ANCHOR,
+  SKILL_SUGGESTION_PREFIX
+} from "./chunk-GOXNB3AO.js";
+import {
+  legacyToolResultDigest,
+  sanitizeToolResultDigest
+} from "./chunk-ODFEOB4F.js";
 import {
   ToolNames
 } from "./chunk-CGKSTWHD.js";
+import {
+  ceilChars
+} from "./chunk-GEYXPTRF.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-VEZEGCGW.js";
-import {
-  ceilChars
-} from "./chunk-BPGS2WCQ.js";
+} from "./chunk-D4MDIG46.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -63,6 +68,10 @@ function metadataNumber(input, key) {
   const value = input.metadata?.[key];
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function metadataString(input, key) {
+  const value = input.metadata?.[key];
+  return typeof value === "string" ? value : null;
+}
 function isMiddlewareHook(value) {
   return MIDDLEWARE_HOOKS.includes(value);
 }
@@ -189,6 +198,7 @@ init_esm_shims();
 init_esm_shims();
 var STALLED_TURN_REGISTRATION_ID = "nudge.stalled-turn";
 var STALLED_TURN_REQUEST_CONTINUATION_MESSAGE = "You ended your turn after announcing an action without executing it: no tools were called. Continue now and perform the announced action, or state plainly that you are finished and waiting for the user.";
+var SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE = "You ended your turn on a skill suggestion without doing the task. The suggestion line has already made the offer and only the operator loads a skill, so nothing is needed from them before you proceed. Continue the task now without the skill.";
 var INTENT_PATTERN = /\b(let me|i['’]ll|i will|i am going to|i['’]m going to|now i|next i|let's|let us)\b/i;
 var CONCRETE_ACTION_STEMS = [
   "add",
@@ -288,6 +298,24 @@ var STALLED_TURN_RULE_DEFINITION = {
   effects: [{ kind: "request_continuation", message: STALLED_TURN_REQUEST_CONTINUATION_MESSAGE }],
   predicate: shouldRequestStalledTurnContinuation
 };
+var SKILL_WAIT_PATTERN = /\/skill\b|\bskills?\b|\bskip\b/i;
+function isSkillSuggestionWait(input) {
+  if (input.hook !== "turn_end") return false;
+  if (!isNormalStopReason(input.metadata?.stopReason)) return false;
+  const text = input.text ?? "";
+  if (!text.includes(SKILL_SUGGESTION_PREFIX)) return false;
+  const toolNames = metadataString(input, "turnToolNames");
+  if (toolNames === null) {
+    if ((metadataNumber(input, "turnToolCalls") ?? 0) !== 0) return false;
+  } else if (toolNames.split(",").filter((name) => name.length > 0).some((name) => name !== ToolNames.Context)) {
+    return false;
+  }
+  const lastLine = lastNonEmptyLine(text);
+  if (lastLine === null) return false;
+  const finalSentence = lastSentence(lastLine);
+  if (finalSentence.length === 0) return false;
+  return SKILL_WAIT_PATTERN.test(finalSentence) || isQuestion(finalSentence) || LET_ME_KNOW_PATTERN.test(finalSentence);
+}
 function shouldRequestStalledTurnContinuation(input) {
   if (input.hook !== "turn_end") return false;
   if (input.metadata?.turnToolCalls !== 0) return false;
@@ -551,6 +579,12 @@ function cloneHookInput(input) {
   if (input.metadata !== void 0) cloned.metadata = { ...input.metadata };
   if (input.toolArgs !== void 0) cloned.toolArgs = { ...input.toolArgs };
   if (input.toolResultDetails !== void 0) cloned.toolResultDetails = { ...input.toolResultDetails };
+  if (input.toolResultDigest !== void 0) {
+    cloned.toolResultDigest = {
+      text: input.toolResultDigest.text,
+      provenance: { ...input.toolResultDigest.provenance }
+    };
+  }
   if (input.text !== void 0) cloned.text = input.text.slice(0, MIDDLEWARE_HOOK_TEXT_MAX_CHARS);
   return cloned;
 }
@@ -1351,7 +1385,6 @@ var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
 var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 400;
 var MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS = 10;
 var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
-var RESULT_DIGEST_MAX_CHARS = 240;
 var CALL_DESCRIPTION_MAX_CHARS = 180;
 var NO_EFFECTS = [];
 function createMemoryInterventionRegistration(deps) {
@@ -1361,7 +1394,7 @@ function createMemoryInterventionRegistration(deps) {
   let toolStep = 0;
   let lastTurnEndStep = 0;
   let reactivateAfterCompaction = false;
-  let lastInjectedFingerprint = null;
+  let lastInjectedOperationFingerprint = null;
   let currentTask = "(current task unavailable)";
   let toolsSinceMemoryStep = 0;
   let consecutiveErrors = 0;
@@ -1630,12 +1663,12 @@ function createMemoryInterventionRegistration(deps) {
   function observeBeforeTool(input) {
     const prepared = prepareToolStep(input);
     if (prepared === null) return;
-    setBounded(pending, pendingKey(input, prepared.fingerprint), prepared, settings().windowSteps);
+    setBounded(pending, pendingKey(input, prepared.operationFingerprint), prepared, settings().windowSteps);
   }
   function observeAfterTool(input) {
     const fallback = prepareToolStep(input);
     if (fallback === null) return NO_EFFECTS;
-    const key = pendingKey(input, fallback.fingerprint);
+    const key = pendingKey(input, fallback.operationFingerprint);
     const prepared = pending.get(key) ?? fallback;
     pending.delete(key);
     const outcome = input.metadata?.resultKind === "error" ? "error" : "ok";
@@ -1649,11 +1682,13 @@ function createMemoryInterventionRegistration(deps) {
     } else {
       consecutiveErrors = 0;
     }
+    const digest = resultDigest(input, outcome);
     const step = {
       ...prepared,
       step: toolStep,
       outcome,
-      resultDigest: resultDigest(input, outcome)
+      resultDigest: digest.text,
+      resultDigestProvenance: digest.provenance
     };
     trajectory.push(step);
     if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
@@ -1662,19 +1697,19 @@ function createMemoryInterventionRegistration(deps) {
     return annotateRepeatedFailure(step);
   }
   function annotateRepeatedFailure(step) {
-    if (annotatedThisTurn.has(step.fingerprint)) return NO_EFFECTS;
+    if (annotatedThisTurn.has(step.operationFingerprint)) return NO_EFFECTS;
     const occurrences = trajectory.filter(
-      (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+      (candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint
     ).length;
-    const failure = failures.get(step.fingerprint);
+    const failure = failures.get(step.operationFingerprint);
     if (occurrences < 2 || failure === void 0) return NO_EFFECTS;
     const message = boundedReminder(
       `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}. Change the approach rather than repeating it.`,
       settings().maxTokens
     );
     if (message.length === 0) return NO_EFFECTS;
-    annotatedThisTurn.add(step.fingerprint);
-    lastInjectedFingerprint = step.fingerprint;
+    annotatedThisTurn.add(step.operationFingerprint);
+    lastInjectedOperationFingerprint = step.operationFingerprint;
     lastDecision = "injected";
     rulesInjectedSincePromptedStep = true;
     annotatedSinceTurnEnd = true;
@@ -1683,7 +1718,7 @@ function createMemoryInterventionRegistration(deps) {
     return [{ kind: "annotate_tool_result", message, severity: "warn" }];
   }
   function rememberFailure(step) {
-    const previous = failures.get(step.fingerprint);
+    const previous = failures.get(step.operationFingerprint);
     const attempts = (previous?.attempts ?? 0) + 1;
     const firstStep = previous?.firstStep ?? step.step;
     const content = proceduralContent(step.callDescription, attempts, firstStep, step.resultDigest);
@@ -1699,7 +1734,7 @@ function createMemoryInterventionRegistration(deps) {
     }
     setBounded(
       failures,
-      step.fingerprint,
+      step.operationFingerprint,
       {
         entryId,
         attempts,
@@ -1714,20 +1749,20 @@ function createMemoryInterventionRegistration(deps) {
     try {
       for (let index = trajectory.length - 1; index >= 0; index -= 1) {
         const step = trajectory[index];
-        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.fingerprint === lastInjectedFingerprint) {
+        if (step === void 0 || step.outcome !== "error" || step.step <= lastTurnEndStep || step.operationFingerprint === lastInjectedOperationFingerprint) {
           continue;
         }
         const occurrences = trajectory.filter(
-          (candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint
+          (candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint
         ).length;
-        const failure = failures.get(step.fingerprint);
+        const failure = failures.get(step.operationFingerprint);
         if (occurrences < 2 || failure === void 0) continue;
         const message = boundedReminder(
           `Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}.`,
           settings().maxTokens
         );
         if (message.length === 0) return NO_EFFECTS;
-        lastInjectedFingerprint = step.fingerprint;
+        lastInjectedOperationFingerprint = step.operationFingerprint;
         lastInjectedMessage = message;
         lastDecision = "injected";
         rulesInjectedSincePromptedStep = true;
@@ -1769,29 +1804,33 @@ function prepareToolStep(input) {
   const canonical = hashToolCall(toolName, input.toolArgs ?? {});
   return {
     toolName,
-    fingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
+    operationFingerprint: createHash2("sha256").update(canonical).digest("hex").slice(0, 16),
     callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS)
   };
 }
-function pendingKey(input, fingerprint) {
-  return input.toolCallId ?? `anonymous:${fingerprint}`;
+function pendingKey(input, operationFingerprint) {
+  return input.toolCallId ?? `anonymous:${operationFingerprint}`;
 }
 function resultDigest(input, outcome) {
+  if (input.toolResultDigest !== void 0) return sanitizeToolResultDigest(input.toolResultDigest);
   if (outcome === "error") {
     const metadataMessage = input.metadata?.errorMessage;
     if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
-      return shortText(diagnosticLine(metadataMessage), RESULT_DIGEST_MAX_CHARS);
+      return legacyToolResultDigest(diagnosticLine(metadataMessage), { outcome });
     }
     for (const key of ["error", "message"]) {
       const value = input.toolResultDetails?.[key];
       if (typeof value === "string" && value.trim().length > 0) {
-        return shortText(diagnosticLine(value), RESULT_DIGEST_MAX_CHARS);
+        return legacyToolResultDigest(diagnosticLine(value), { outcome });
       }
     }
-    return "an unknown tool error";
+    return legacyToolResultDigest("", { outcome });
   }
   const resultFingerprint = input.metadata?.resultFingerprint;
-  return typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok";
+  return legacyToolResultDigest(
+    typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok",
+    { outcome }
+  );
 }
 var DIAGNOSTIC_HINT = /\b(error|failed|failure|cannot|unable|expected|refused|denied|missing|not found|timed out|timeout|fatal)\b/iu;
 function diagnosticLine(value) {
@@ -1833,7 +1872,7 @@ init_esm_shims();
 var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
 function skillsReminderMessage(installed, installable = 0) {
   const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
-  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and wait for the operator; load only on operator request, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
+  return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and then continue the task in the same turn without the skill. Only the operator loads a skill, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
 }
 var NO_EFFECTS2 = [];
 var GREETING_WORDS = /* @__PURE__ */ new Set([
@@ -1887,9 +1926,12 @@ function createSkillsReminderRegistration(deps) {
   let observedAnyTurn = false;
   return {
     id: SKILLS_REMINDER_REGISTRATION_ID,
-    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol",
-    hooks: ["turn_start"],
+    description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
+    hooks: ["turn_start", "turn_end"],
     evaluate(input) {
+      if (input.hook === "turn_end") {
+        return isSkillSuggestionWait(input) ? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }] : NO_EFFECTS2;
+      }
       const sessionId = input.sessionId ?? null;
       if (lastSeenSessionId === void 0) {
         lastSeenSessionId = sessionId;
@@ -2055,6 +2097,153 @@ function createMiddlewareToolChoiceControl() {
   };
 }
 
+// src/domains/middleware/watchdog.ts
+init_esm_shims();
+var WATCHDOG_REGISTRATION_ID = "observer.watchdog";
+var WATCHDOG_DIFF_MAX_BYTES = 12 * 1024;
+var WATCHDOG_PATHS_MAX = 40;
+var WATCHDOG_TRUNCATION_MARKER = "\n[diff truncated]";
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([ToolNames.Write, ToolNames.Edit, ToolNames.Artifact]);
+var NO_EFFECTS4 = [];
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function firstPath(details) {
+  const paths = details?.paths;
+  if (!Array.isArray(paths)) return null;
+  for (const entry of paths) {
+    const path = stringValue2(entry);
+    if (path !== null) return path;
+  }
+  return null;
+}
+function coalesceTurnDiff(byPath, maxBytes = WATCHDOG_DIFF_MAX_BYTES) {
+  const blocks = [];
+  let index = 0;
+  for (const [path, diff] of byPath) {
+    if (index >= WATCHDOG_PATHS_MAX) {
+      blocks.push(`[${byPath.size - WATCHDOG_PATHS_MAX} more changed path(s) omitted]`);
+      break;
+    }
+    blocks.push(`--- ${path}
+${diff}`);
+    index += 1;
+  }
+  const whole = blocks.join("\n\n");
+  if (Buffer.byteLength(whole, "utf8") <= maxBytes) return whole;
+  const room = Math.max(0, maxBytes - Buffer.byteLength(WATCHDOG_TRUNCATION_MARKER, "utf8"));
+  const buffer = Buffer.from(whole, "utf8");
+  let cut = Math.min(room, buffer.byteLength);
+  while (cut > 0) {
+    const next = buffer[cut];
+    if (next === void 0 || (next & 192) !== 128) break;
+    cut -= 1;
+  }
+  return `${buffer.subarray(0, cut).toString("utf8")}${WATCHDOG_TRUNCATION_MARKER}`;
+}
+var WATCHDOG_TASK = "Review the coalesced diff in the briefing against the scope it names. Report one check per concern: a change outside the stated scope, a change the scope required that the diff does not make, or a defect visible in the diff itself. Run no commands and change nothing.";
+function watchdogBriefing(trigger) {
+  const scope = trigger.scope === null ? "(no task board; scope is unstated)" : trigger.scope;
+  const paths = trigger.paths.length === 0 ? "(none)" : trigger.paths.join("\n");
+  return [
+    "## Current scope",
+    scope,
+    "",
+    "## Changed paths",
+    paths,
+    "",
+    "## Coalesced diff for this turn",
+    trigger.diff
+  ].join("\n");
+}
+function createWatchdogRegistration(deps) {
+  const diffByPath = /* @__PURE__ */ new Map();
+  let toolCalls = 0;
+  let dropped = 0;
+  let inFlight = false;
+  let outstanding = Promise.resolve();
+  const active = () => {
+    if (deps.firesOnThisSurface === false) return null;
+    let settings;
+    try {
+      settings = deps.getSettings();
+    } catch {
+      return null;
+    }
+    return settings.enabled ? settings : null;
+  };
+  const resetTurn = () => {
+    diffByPath.clear();
+    toolCalls = 0;
+  };
+  const fire = (reason) => {
+    if (diffByPath.size === 0) return;
+    if (inFlight) {
+      dropped += 1;
+      return;
+    }
+    const trigger = {
+      reason,
+      diff: coalesceTurnDiff(diffByPath),
+      paths: [...diffByPath.keys()].slice(0, WATCHDOG_PATHS_MAX),
+      scope: scopeNow(),
+      toolCalls
+    };
+    inFlight = true;
+    let started;
+    try {
+      started = deps.run(trigger);
+    } catch {
+      inFlight = false;
+      return;
+    }
+    outstanding = started.catch(() => {
+    }).finally(() => {
+      inFlight = false;
+    });
+  };
+  const scopeNow = () => {
+    try {
+      return deps.getScope?.() ?? null;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    id: WATCHDOG_REGISTRATION_ID,
+    description: "review a mutating turn's coalesced diff against the board scope with a read-only verifier run",
+    hooks: ["after_tool", "turn_end"],
+    evaluate(input) {
+      const settings = active();
+      if (settings === null) {
+        if (input.hook === "turn_end") resetTurn();
+        return NO_EFFECTS4;
+      }
+      if (input.hook === "after_tool") {
+        toolCalls += 1;
+        recordMutation(input);
+        const cadence = settings.cadenceToolCalls;
+        if (cadence !== void 0 && cadence >= 1 && toolCalls % cadence === 0) fire("cadence");
+        return NO_EFFECTS4;
+      }
+      if (input.hook !== "turn_end") return NO_EFFECTS4;
+      fire("turn_end");
+      resetTurn();
+      return NO_EFFECTS4;
+    },
+    droppedTriggers: () => dropped,
+    runInFlight: () => inFlight,
+    whenIdle: () => outstanding
+  };
+  function recordMutation(input) {
+    if (input.metadata?.resultKind !== "ok") return;
+    if (input.toolName === void 0 || !MUTATING_TOOL_NAMES.has(input.toolName)) return;
+    const diff = stringValue2(input.toolResultDetails?.diff);
+    if (diff === null) return;
+    diffByPath.set(firstPath(input.toolResultDetails) ?? input.toolName, diff);
+  }
+}
+
 // src/domains/middleware/index.ts
 init_esm_shims();
 
@@ -2210,6 +2399,9 @@ export {
   createTaskBoardReminderRegistration,
   createTaskNudgeRegistration,
   createMiddlewareToolChoiceControl,
+  WATCHDOG_TASK,
+  watchdogBriefing,
+  createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-2LZI5CAG.js.map
+//# sourceMappingURL=chunk-XEGB6BCN.js.map

package/dist/{chunk-E25LMLRW.js → chunk-YD734TPH.js}

@@ -5,7 +5,7 @@ import {
   settingsPath,
   updateSavedSettingsDocument,
   validateSettings
-} from "./chunk-AD2SYQYC.js";
+} from "./chunk-UHXRNZ2J.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -226,4 +226,4 @@ export {
   updateLayeredSettings,
   settingsSourceFor
 };
-//# sourceMappingURL=chunk-E25LMLRW.js.map
+//# sourceMappingURL=chunk-YD734TPH.js.map