poe-code 3.0.220 → 3.0.221

package/dist/index.js

@@ -9154,6 +9154,7 @@ function formatElapsed2(ms) {
 }
 async function withSpinner(options) {
   const { message: message2, fn, stopMessage, subtext } = options;
+  const readMessage = () => typeof message2 === "function" ? message2() : message2;
   if (resolveOutputFormat() === "json") {
     const result = await fn();
     const sub = subtext ? subtext(result) : void 0;
@@ -9182,9 +9183,9 @@ async function withSpinner(options) {
   }
   const s = spinner();
   const start = Date.now();
-  s.start(message2);
+  s.start(readMessage());
   const timer = setInterval(() => {
-    s.message(`${message2} [${formatElapsed2(Date.now() - start)}]`);
+    s.message(`${readMessage()} [${formatElapsed2(Date.now() - start)}]`);
   }, 1e3);
   try {
     const result = await fn();
@@ -70879,6 +70880,29 @@ function isImportMetaReference(node) {
   }
   return node.type === "MemberExpression" && (isImportMetaReference(node.object) || node.computed && isImportMetaReference(node.property));
 }
+function isAssignmentOperator(value) {
+  switch (value) {
+    case "=":
+    case "+=":
+    case "-=":
+    case "*=":
+    case "/=":
+    case "%=":
+    case "**=":
+    case "&=":
+    case "|=":
+    case "^=":
+    case "<<=":
+    case ">>=":
+    case ">>>=":
+    case "&&=":
+    case "||=":
+    case "??=":
+      return true;
+    default:
+      return false;
+  }
+}
 function createNumericLiteral(token) {
   return {
     type: "NumericLiteral",
@@ -71404,14 +71428,15 @@ var init_parser3 = __esm({
           };
         }
         const left = this.parseConditionalExpression();
-        if (this.consumePunctuator("=") === void 0) {
+        const operator = this.consumeAssignmentOperator();
+        if (operator === void 0) {
           return left;
         }
         const right = this.parseAssignmentExpression();
         return {
           node: {
             type: "AssignmentExpression",
-            operator: "=",
+            operator,
             left: this.toAssignmentTarget(left.node),
             right: right.node,
             span: createSpan2(left.node.span.start, right.node.span.end)
@@ -73130,6 +73155,14 @@ var init_parser3 = __esm({
         this.index += 1;
         return token;
       }
+      consumeAssignmentOperator() {
+        const token = this.currentToken();
+        if (token.type !== "punctuator" || !isAssignmentOperator(token.value)) {
+          return void 0;
+        }
+        this.index += 1;
+        return token.value;
+      }
       expectPunctuator(value) {
         const token = this.currentToken();
         if (token.type !== "punctuator" || token.value !== value) {
@@ -74380,7 +74413,10 @@ var init_AS002 = __esm({
 
 // packages/agent-script/src/lint/rules/AS003.ts
 function AS003(source, options = {}) {
-  return new AS003Scanner(options.filename ?? "<input>").scan(source);
+  return new AS003Scanner(
+    options.filename ?? "<input>",
+    /* @__PURE__ */ new Set([...DEFAULT_ALLOWED_GLOBALS, ...options.allowedGlobals ?? []])
+  ).scan(source);
 }
 function formatNearMatchMessage(names) {
   if (names.length === 1) {
@@ -74413,16 +74449,31 @@ function getLevenshteinDistance2(left, right) {
   }
   return previous[right.length];
 }
-var AS003Scanner;
+var DEFAULT_ALLOWED_GLOBALS, AS003Scanner;
 var init_AS003 = __esm({
   "packages/agent-script/src/lint/rules/AS003.ts"() {
     "use strict";
     init_parser3();
+    DEFAULT_ALLOWED_GLOBALS = [
+      "Array",
+      "Boolean",
+      "Error",
+      "JSON",
+      "Math",
+      "Number",
+      "Object",
+      "Promise",
+      "String",
+      "TypeError",
+      "console"
+    ];
     AS003Scanner = class {
-      constructor(filename) {
+      constructor(filename, allowedGlobals) {
         this.filename = filename;
+        this.allowedGlobals = allowedGlobals;
       }
       filename;
+      allowedGlobals;
       diagnostics = [];
       scopes = [];
       scan(source) {
@@ -74780,8 +74831,11 @@ var init_AS003 = __esm({
         if (this.resolveBinding(node.name) !== void 0) {
           return;
         }
+        if (this.allowedGlobals.has(node.name)) {
+          return;
+        }
         const visibleNames = this.collectVisibleNames();
-        const nearMatches = visibleNames.map((name) => ({ distance: getLevenshteinDistance2(node.name, name), name })).filter((entry) => entry.distance <= 2).sort((left, right) => left.distance - right.distance || left.name.localeCompare(right.name)).map((entry) => entry.name);
+        const nearMatches = this.collectSuggestionNames(visibleNames).map((name) => ({ distance: getLevenshteinDistance2(node.name, name), name })).filter((entry) => entry.distance <= 2).sort((left, right) => left.distance - right.distance || left.name.localeCompare(right.name)).map((entry) => entry.name);
         const message2 = nearMatches.length > 0 ? `Unknown identifier '${node.name}'. ${formatNearMatchMessage(nearMatches)}` : `Unknown identifier '${node.name}'. ${formatVisibleNamesMessage(visibleNames)}`;
         this.diagnostics.push({
           code: "AS003",
@@ -74820,6 +74874,10 @@ var init_AS003 = __esm({
         }
         return [...names].sort((left, right) => left.localeCompare(right));
       }
+      collectSuggestionNames(visibleNames) {
+        const names = /* @__PURE__ */ new Set([...visibleNames, ...this.allowedGlobals]);
+        return [...names].sort((left, right) => left.localeCompare(right));
+      }
       collectModuleBindings(body) {
         const bindings = [];
         for (const statement of body) {
@@ -80989,12 +81047,138 @@ async function evaluateObjectExpression(node, context) {
     value: object
   };
 }
+async function evaluateTemplateLiteral(node, context) {
+  let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
+  for (let index = 0; index < node.expressions.length; index += 1) {
+    const expression = await evaluateNode(node.expressions[index], context);
+    if (expression.kind !== "normal") {
+      return expression;
+    }
+    const expressionText = context.budget.allocateString(String(expression.value));
+    value = context.budget.allocateString(value + expressionText);
+    const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
+    value = context.budget.allocateString(value + quasiText);
+  }
+  return {
+    kind: "normal",
+    hasValue: true,
+    value
+  };
+}
 async function evaluateArrowFunction(node, context) {
   return evaluateArrowFunctionExpression(node, context, evaluateNode);
 }
 async function evaluateAwait(node, context) {
   return evaluateAwaitExpression(node, context, evaluateNode);
 }
+async function evaluateBinaryExpression(node, context) {
+  const left = await evaluateNode(node.left, context);
+  if (left.kind !== "normal") {
+    return left;
+  }
+  const right = await evaluateNode(node.right, context);
+  if (right.kind !== "normal") {
+    return right;
+  }
+  const value = applyBinaryOperator(node, left.value, right.value, context);
+  return {
+    kind: "normal",
+    hasValue: true,
+    value
+  };
+}
+async function evaluateAssignmentExpression(node, context) {
+  if (node.left.type === "MemberExpression") {
+    throw new Error("member-target assignment is not supported");
+  }
+  if (node.left.type !== "Identifier") {
+    return {
+      kind: "error",
+      error: createError(
+        "UNSUPPORTED_NODE",
+        node,
+        `Unsupported assignment target '${node.left.type}'.`
+      )
+    };
+  }
+  const binding = context.scope.lookup(node.left.name);
+  if (!binding.found) {
+    return {
+      kind: "error",
+      error: createError(
+        "UNBOUND_IDENTIFIER",
+        node.left,
+        `Identifier '${node.left.name}' is not defined.`
+      )
+    };
+  }
+  if (binding.kind === "const") {
+    throw new Error(`Cannot assign to const '${node.left.name}'`);
+  }
+  if (node.operator === "&&=" && !isTruthy(binding.value)) {
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: binding.value
+    };
+  }
+  if (node.operator === "||=" && isTruthy(binding.value)) {
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: binding.value
+    };
+  }
+  if (node.operator === "??=" && binding.value !== null && binding.value !== void 0) {
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: binding.value
+    };
+  }
+  const right = await evaluateNode(node.right, context);
+  if (right.kind !== "normal") {
+    return right;
+  }
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, binding.value, right.value, context);
+  context.scope.assign(node.left.name, value);
+  return {
+    kind: "normal",
+    hasValue: true,
+    value
+  };
+}
+async function evaluateLogicalExpression(node, context) {
+  const left = await evaluateNode(node.left, context);
+  if (left.kind !== "normal") {
+    return left;
+  }
+  switch (node.operator) {
+    case "&&":
+      if (!isTruthy(left.value)) {
+        return left;
+      }
+      break;
+    case "||":
+      if (isTruthy(left.value)) {
+        return left;
+      }
+      break;
+    case "??":
+      if (left.value !== null && left.value !== void 0) {
+        return left;
+      }
+      break;
+  }
+  return evaluateNode(node.right, context);
+}
+async function evaluateConditionalExpression(node, context) {
+  const test = await evaluateNode(node.test, context);
+  if (test.kind !== "normal") {
+    return test;
+  }
+  return evaluateNode(isTruthy(test.value) ? node.consequent : node.alternate, context);
+}
 async function evaluateIdentifier(node, context) {
   const binding = context.scope.lookup(node.name);
   if (!binding.found) {
@@ -81033,9 +81217,6 @@ async function evaluateExportNamedDeclaration(node, context) {
 }
 async function evaluateVariableDeclaration(node, context) {
   for (const declarator of node.declarations) {
-    if (declarator.id.type !== "Identifier") {
-      throw new TypeError(`Unsupported variable declaration pattern '${declarator.id.type}'.`);
-    }
     const value = declarator.init === void 0 ? {
       kind: "normal",
       hasValue: true,
@@ -81044,7 +81225,10 @@ async function evaluateVariableDeclaration(node, context) {
     if (value.kind !== "normal") {
       return value;
     }
-    context.scope.declare(declarator.id.name, node.kind, value.value);
+    const binding = await bindDeclarationPattern(declarator.id, value.value, node.kind, context);
+    if (!binding.ok) {
+      return binding.result;
+    }
   }
   return {
     kind: "normal",
@@ -81052,6 +81236,107 @@ async function evaluateVariableDeclaration(node, context) {
     value: void 0
   };
 }
+async function bindDeclarationPattern(pattern, value, kind, context) {
+  switch (pattern.type) {
+    case "Identifier":
+      context.scope.declare(pattern.name, kind, value);
+      return { ok: true };
+    case "MemberExpression":
+      throw new TypeError("Destructuring declarations cannot bind to member expressions.");
+    case "AssignmentPattern":
+      return bindDeclarationAssignmentPattern(pattern, value, kind, context);
+    case "ArrayPattern":
+      return bindDeclarationArrayPattern(pattern, value, kind, context);
+    case "ObjectPattern":
+      return bindDeclarationObjectPattern(pattern, value, kind, context);
+    case "RestElement":
+      return bindDeclarationPattern(pattern.argument, value, kind, context);
+  }
+}
+async function bindDeclarationAssignmentPattern(pattern, value, kind, context) {
+  if (value !== void 0) {
+    return bindDeclarationPattern(pattern.left, value, kind, context);
+  }
+  const defaultValue = await evaluateNode(pattern.right, context);
+  if (defaultValue.kind !== "normal") {
+    return {
+      ok: false,
+      result: defaultValue
+    };
+  }
+  return bindDeclarationPattern(pattern.left, defaultValue.value, kind, context);
+}
+async function bindDeclarationArrayPattern(pattern, value, kind, context) {
+  if (!Array.isArray(value)) {
+    throw new TypeError("Array destructuring declarations require an array value.");
+  }
+  for (let index = 0; index < pattern.elements.length; index += 1) {
+    const element = pattern.elements[index];
+    if (element === null) {
+      continue;
+    }
+    const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
+    const binding = await bindDeclarationPattern(element, elementValue, kind, context);
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function bindDeclarationObjectPattern(pattern, value, kind, context) {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const binding2 = await bindDeclarationPattern(
+        property,
+        copyObjectRestValue(value, excludedKeys),
+        kind,
+        context
+      );
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key2 = await evaluateDeclarationPatternKey(property, context);
+    if (!key2.ok) {
+      return key2;
+    }
+    excludedKeys.add(String(key2.value));
+    const binding = await bindDeclarationPattern(
+      property.value,
+      value[key2.value],
+      kind,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
+    }
+  }
+  return { ok: true };
+}
+async function evaluateDeclarationPatternKey(property, context) {
+  if (!property.computed) {
+    return {
+      ok: true,
+      value: getStaticPropertyName(property.key)
+    };
+  }
+  return evaluateMemberProperty(property.key, context);
+}
+function copyObjectRestValue(value, excludedKeys) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  for (const [key2, entryValue] of Object.entries(value)) {
+    if (excludedKeys.has(key2)) {
+      continue;
+    }
+    defineSandboxProperty(rest, key2, entryValue);
+  }
+  return rest;
+}
 async function evaluateBlockStatement(node, context) {
   for (const statement of node.body) {
     const result = await evaluateNode(statement, context);
@@ -81065,6 +81350,144 @@ async function evaluateBlockStatement(node, context) {
     value: void 0
   };
 }
+async function evaluateIfStatement(node, context) {
+  const test = await evaluateNode(node.test, context);
+  if (test.kind !== "normal") {
+    return test;
+  }
+  const branch = isTruthy(test.value) ? node.consequent : node.alternate;
+  if (branch === void 0) {
+    return {
+      kind: "normal",
+      hasValue: false,
+      value: void 0
+    };
+  }
+  return evaluateNode(branch, context);
+}
+async function evaluateForOfStatement(node, context) {
+  const iterable = await evaluateNode(node.right, context);
+  if (iterable.kind !== "normal") {
+    return iterable;
+  }
+  if (!Array.isArray(iterable.value)) {
+    throw new TypeError(`${String(iterable.value)} is not a supported iterable`);
+  }
+  for (const entry of iterable.value) {
+    const scope = context.scope.child();
+    bindForOfLoopVariable(node.left, entry, scope);
+    const result = await evaluateNode(node.body, {
+      ...context,
+      scope
+    });
+    if (result.kind === "break") {
+      return {
+        kind: "normal",
+        hasValue: false,
+        value: void 0
+      };
+    }
+    if (result.kind === "continue") {
+      continue;
+    }
+    if (result.kind !== "normal") {
+      return result;
+    }
+  }
+  return {
+    kind: "normal",
+    hasValue: false,
+    value: void 0
+  };
+}
+async function evaluateForStatement(node, context) {
+  const loopContext = {
+    ...context,
+    scope: context.scope.child()
+  };
+  if (node.init !== void 0) {
+    const init = await evaluateNode(node.init, loopContext);
+    if (init.kind !== "normal") {
+      return init;
+    }
+  }
+  while (true) {
+    context.budget.visitNode();
+    context.stats.nodeVisits += 1;
+    if (node.test !== void 0) {
+      const test = await evaluateNode(node.test, loopContext);
+      if (test.kind !== "normal") {
+        return test;
+      }
+      if (!isTruthy(test.value)) {
+        return {
+          kind: "normal",
+          hasValue: false,
+          value: void 0
+        };
+      }
+    }
+    const result = await evaluateNode(node.body, loopContext);
+    if (result.kind === "break") {
+      return {
+        kind: "normal",
+        hasValue: false,
+        value: void 0
+      };
+    }
+    if (result.kind !== "normal" && result.kind !== "continue") {
+      return result;
+    }
+    if (node.update !== void 0) {
+      const update = await evaluateNode(node.update, loopContext);
+      if (update.kind !== "normal") {
+        return update;
+      }
+    }
+  }
+}
+async function evaluateWhileStatement(node, context) {
+  while (true) {
+    const test = await evaluateNode(node.test, context);
+    if (test.kind !== "normal") {
+      return test;
+    }
+    if (!isTruthy(test.value)) {
+      return {
+        kind: "normal",
+        hasValue: false,
+        value: void 0
+      };
+    }
+    const result = await evaluateNode(node.body, context);
+    if (result.kind === "break") {
+      return {
+        kind: "normal",
+        hasValue: false,
+        value: void 0
+      };
+    }
+    if (result.kind === "continue") {
+      continue;
+    }
+    if (result.kind !== "normal") {
+      return result;
+    }
+  }
+}
+function bindForOfLoopVariable(left, value, scope) {
+  if (left.type !== "VariableDeclaration") {
+    throw new TypeError(`Unsupported for...of left-hand side '${left.type}'.`);
+  }
+  const [declarator] = left.declarations;
+  if (left.declarations.length !== 1 || declarator === void 0) {
+    throw new TypeError("for...of declarations must include exactly one declarator.");
+  }
+  if (declarator.id.type !== "Identifier") {
+    throw new TypeError(`Unsupported for...of declaration pattern '${declarator.id.type}'.`);
+  }
+  scope.declare(declarator.id.name, left.kind, value);
+}
 async function evaluateExpressionStatement(node, context) {
   return evaluateNode(node.expression, context);
 }
@@ -81376,6 +81799,99 @@ function applyUnaryOperator(operator, value) {
       return ~value;
   }
 }
+function isTruthy(value) {
+  return applyUnaryOperator("!", value) === false;
+}
+function applyBinaryOperator(node, left, right, context) {
+  switch (node.operator) {
+    case "+":
+      return applyAdditionOperator(left, right, context);
+    case "-":
+      return Number(left) - Number(right);
+    case "*":
+      return Number(left) * Number(right);
+    case "/":
+      return Number(left) / Number(right);
+    case "%":
+      return Number(left) % Number(right);
+    case "**":
+      return Number(left) ** Number(right);
+    case "<":
+      return compareLessThan(left, right);
+    case "<=":
+      return compareLessThanOrEqual(left, right);
+    case ">":
+      return compareGreaterThan(left, right);
+    case ">=":
+      return compareGreaterThanOrEqual(left, right);
+    case "===":
+    case "==":
+      return left === right;
+    case "!==":
+    case "!=":
+      return left !== right;
+    case "&":
+      return Number(left) & Number(right);
+    case "|":
+      return Number(left) | Number(right);
+    case "^":
+      return Number(left) ^ Number(right);
+    case "<<":
+      return Number(left) << Number(right);
+    case ">>":
+      return Number(left) >> Number(right);
+    case ">>>":
+      return Number(left) >>> Number(right);
+    case "in":
+      throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
+  }
+}
+function applyCompoundAssignmentOperator(operator, left, right, context) {
+  switch (operator) {
+    case "+=":
+      return applyAdditionOperator(left, right, context);
+    case "-=":
+      return Number(left) - Number(right);
+    case "*=":
+      return Number(left) * Number(right);
+    case "/=":
+      return Number(left) / Number(right);
+    case "%=":
+      return Number(left) % Number(right);
+    case "**=":
+      return Number(left) ** Number(right);
+    case "&=":
+      return Number(left) & Number(right);
+    case "|=":
+      return Number(left) | Number(right);
+    case "^=":
+      return Number(left) ^ Number(right);
+    case "<<=":
+      return Number(left) << Number(right);
+    case ">>=":
+      return Number(left) >> Number(right);
+    case ">>>=":
+      return Number(left) >>> Number(right);
+  }
+}
+function applyAdditionOperator(left, right, context) {
+  if (typeof left === "string" || typeof right === "string") {
+    return context.budget.allocateString(String(left) + String(right));
+  }
+  return Number(left) + Number(right);
+}
+function compareLessThan(left, right) {
+  return typeof left === "string" && typeof right === "string" ? left < right : Number(left) < Number(right);
+}
+function compareLessThanOrEqual(left, right) {
+  return typeof left === "string" && typeof right === "string" ? left <= right : Number(left) <= Number(right);
+}
+function compareGreaterThan(left, right) {
+  return typeof left === "string" && typeof right === "string" ? left > right : Number(left) > Number(right);
+}
+function compareGreaterThanOrEqual(left, right) {
+  return typeof left === "string" && typeof right === "string" ? left >= right : Number(left) >= Number(right);
+}
 function isIndexableSandboxValue(value) {
   return Array.isArray(value) || isPlainSandboxObject(value);
 }
@@ -81504,15 +82020,37 @@ async function evaluateObjectSpread(node, context) {
       result: value
     };
   }
-  if (!isIndexableSandboxValue(value.value)) {
-    throw new TypeError("Spread properties must evaluate to an object or array.");
+  if (Array.isArray(value.value)) {
+    throw new TypeError("Cannot spread array into object literal.");
+  }
+  if (!isPlainSandboxObject(value.value)) {
+    throw new TypeError(
+      `Cannot spread ${describeObjectSpreadValue(value.value)} into object literal.`
+    );
   }
   const spreadValue = value.value;
+  const keys = Object.keys(spreadValue);
+  context.budget.allocateArrayLength(keys.length);
   return {
     ok: true,
-    value: Object.keys(spreadValue).map((key2) => [key2, getMemberValue(spreadValue, key2)])
+    value: keys.map((key2) => [key2, spreadValue[key2]])
   };
 }
+function describeObjectSpreadValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (isSandboxClosure(value)) {
+    return "function";
+  }
+  if (isSandboxPromise(value)) {
+    return "promise";
+  }
+  return typeof value;
+}
 function defineSandboxProperty(target, key2, value) {
   Object.defineProperty(target, key2, {
     configurable: true,
@@ -81559,16 +82097,23 @@ var init_interpreter = __esm({
     init_scope();
     dispatchTable = {
       ArrayExpression: evaluateArrayExpression,
+      AssignmentExpression: evaluateAssignmentExpression,
       ArrowFunctionExpression: evaluateArrowFunction,
       AwaitExpression: evaluateAwait,
+      BinaryExpression: evaluateBinaryExpression,
       BlockStatement: evaluateBlockStatement,
       BooleanLiteral: evaluatePrimitiveLiteral,
       CallExpression: evaluateCallExpression,
+      ConditionalExpression: evaluateConditionalExpression,
       ContinueStatement: evaluateContinueStatement,
       ExportDefaultDeclaration: evaluateExportDefaultDeclaration,
       ExportNamedDeclaration: evaluateExportNamedDeclaration,
       ExpressionStatement: evaluateExpressionStatement,
+      ForOfStatement: evaluateForOfStatement,
+      ForStatement: evaluateForStatement,
+      IfStatement: evaluateIfStatement,
       Identifier: evaluateIdentifier,
+      LogicalExpression: evaluateLogicalExpression,
       MemberExpression: evaluateMemberExpression,
       MetaProperty: evaluateMetaProperty,
       NullLiteral: evaluatePrimitiveLiteral,
@@ -81577,10 +82122,12 @@ var init_interpreter = __esm({
       BreakStatement: evaluateBreakStatement,
       ReturnStatement: evaluateReturnStatement,
       StringLiteral: evaluatePrimitiveLiteral,
+      TemplateLiteral: evaluateTemplateLiteral,
       ThrowStatement: evaluateThrowStatement2,
       TryStatement: evaluateTryStatement2,
       UnaryExpression: evaluateUnaryExpression,
       VariableDeclaration: evaluateVariableDeclaration,
+      WhileStatement: evaluateWhileStatement,
       UndefinedLiteral: evaluatePrimitiveLiteral
     };
   }
@@ -85315,6 +85862,7 @@ var init_git2 = __esm({
 // packages/agent-script/src/modules/harness.ts
 function makeHarnessModule(frontmatter, meta) {
   const copiedFrontmatter = copyHarnessValue(frontmatter);
+  const constraints = readConstraints(copiedFrontmatter);
   return {
     tasks: copyHarnessValue(copiedFrontmatter.tasks),
     agents: copyHarnessValue(copiedFrontmatter.agents),
@@ -85323,12 +85871,40 @@ function makeHarnessModule(frontmatter, meta) {
       version: copyHarnessValue(meta.version),
       filepath: meta.filepath,
       frontmatter: copiedFrontmatter
-    }
+    },
+    applyConstraints: (prompt) => applyConstraints(prompt, constraints)
   };
 }
 function copyHarnessValue(value) {
   return deepCopyToSandbox(value);
 }
+function readConstraints(frontmatter) {
+  const constraints = /* @__PURE__ */ new Set();
+  appendConstraintValues(constraints, frontmatter.principles);
+  appendConstraintValues(constraints, frontmatter.constraints);
+  return [...constraints];
+}
+function appendConstraintValues(constraints, value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new Error("constraints/principles must be strings");
+    }
+    constraints.add(item);
+  }
+}
+function applyConstraints(prompt, constraints) {
+  if (constraints.length === 0) {
+    return prompt;
+  }
+  const preamble = `CONSTRAINTS (hard rules, honor all):
+${constraints.map((constraint) => `- ${constraint}`).join("\n")}`;
+  return prompt.length === 0 ? preamble : `${preamble}
+
+${prompt}`;
+}
 var init_harness = __esm({
   "packages/agent-script/src/modules/harness.ts"() {
     "use strict";
@@ -85546,7 +86122,11 @@ async function extractSchema(ajsSource, ajsPath) {
   );
   const result = await evaluateSchemaInitializer(initializerSource, ajsPath);
   if (!result.ok) {
-    throwSchemaInitializerError(ajsPath, result.error.message);
+    throwSchemaInitializerError(
+      ajsPath,
+      result.error,
+      findPriorOuterSchemaBinding(module, initializer.span.start.offset, result.error)
+    );
   }
   return await deepCopyFromSandbox(result.returnValue);
 }
@@ -85563,13 +86143,62 @@ async function evaluateSchemaInitializer(initializerSource, ajsPath) {
     throwSchemaInitializerError(ajsPath, error3);
   }
 }
-function throwSchemaInitializerError(ajsPath, cause) {
+function throwSchemaInitializerError(ajsPath, cause, outerSchemaBindingName) {
+  if (outerSchemaBindingName !== void 0) {
+    throw new Error(
+      `Failed to evaluate schema initializer in ${ajsPath}: schema initializer is evaluated in isolation; outer const '${outerSchemaBindingName}' is not in scope. Inline the value or move it into the schema literal.`,
+      { cause }
+    );
+  }
   const detail = readErrorMessage2(cause);
   throw new Error(
     `Failed to evaluate schema initializer in ${ajsPath}: schema initializer must be pure; only "schema" module imports allowed. ${detail}`,
     { cause }
   );
 }
+function findPriorOuterSchemaBinding(module, initializerStartOffset, cause) {
+  const unboundName = readUnboundIdentifierName(cause);
+  if (unboundName === void 0) {
+    return void 0;
+  }
+  return collectPriorTopLevelBindings(module, initializerStartOffset).has(unboundName) ? unboundName : void 0;
+}
+function collectPriorTopLevelBindings(module, initializerStartOffset) {
+  const bindingNames = /* @__PURE__ */ new Set();
+  for (const statement of module.body) {
+    const declaration = readVariableDeclaration(statement);
+    if (declaration === void 0 || declaration.kind !== "const" && declaration.kind !== "let") {
+      continue;
+    }
+    for (const declarator of declaration.declarations) {
+      if (declarator.id.type === "Identifier" && declarator.id.span.start.offset < initializerStartOffset) {
+        bindingNames.add(declarator.id.name);
+      }
+    }
+  }
+  return bindingNames;
+}
+function readVariableDeclaration(statement) {
+  if (statement.type === "VariableDeclaration") {
+    return statement;
+  }
+  if (statement.type === "ExportNamedDeclaration") {
+    return statement.declaration;
+  }
+  return void 0;
+}
+function readUnboundIdentifierName(error3) {
+  if (typeof error3 !== "object" || error3 === null || !("code" in error3) || error3.code !== "UNBOUND_IDENTIFIER") {
+    return void 0;
+  }
+  const message2 = readErrorMessage2(error3);
+  const prefix = "Identifier '";
+  if (!message2.startsWith(prefix)) {
+    return void 0;
+  }
+  const nameEnd = message2.indexOf("'", prefix.length);
+  return nameEnd === -1 ? void 0 : message2.slice(prefix.length, nameEnd);
+}
 function readErrorMessage2(error3) {
   if (error3 instanceof Error) {
     return error3.message;
@@ -85770,17 +86399,24 @@ async function runHarnessPair(mdPath, options) {
       body
     };
     const snapshotPath = resolveSnapshotPath(pair.mdPath, options.snapshotPath);
+    const shouldResume = options.resume ?? true;
+    if (!shouldResume) {
+      await cleanupCompletedSnapshot(snapshotPath);
+    }
     const hostCallReplay = await createHostCallReplay(snapshotPath);
-    const modules = withSchemaModule(hostCallReplay.wrapModules(options.modulesFor(validated, meta)));
+    const modules = withSchemaModule(
+      hostCallReplay.wrapModules(options.modulesFor(validated, meta))
+    );
     throwOnLintErrors([
       ...lint(ajsSource, {
         allowedExportNames: ["schema"],
+        allowedGlobals: options.allowedGlobals,
         filename: pair.ajsPath,
         modules: createLintModules(modules)
       }),
       ...missingDefaultExportDiagnostics(ajsSource, pair.ajsPath)
     ]);
-    const snapshot2 = await readSnapshot(snapshotPath);
+    const snapshot2 = shouldResume ? await readSnapshot(snapshotPath) : void 0;
     let result;
     try {
       result = await run(ajsSource, {
@@ -85825,7 +86461,9 @@ function throwOnLintErrors(diagnostics) {
 }
 function missingDefaultExportDiagnostics(source, filename) {
   const module = parseModule(source, filename);
-  const hasDefaultExport = module.body.some((statement) => statement.type === "ExportDefaultDeclaration");
+  const hasDefaultExport = module.body.some(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
   if (hasDefaultExport) {
     return [];
   }
@@ -85985,7 +86623,9 @@ function isPromiseLike5(value) {
 function createLintModules(modules) {
   const entries = modules instanceof Map ? [...modules.entries()] : Object.entries(modules);
   return new Map(
-    entries.map(([moduleName, moduleExports]) => [moduleName, listModuleExports(moduleExports)])
+    entries.map(
+      ([moduleName, moduleExports]) => [moduleName, listModuleExports(moduleExports)]
+    )
   );
 }
 function listModuleExports(moduleExports) {
@@ -86056,6 +86696,7 @@ import { fileURLToPath as fileURLToPath14 } from "node:url";
 function listBuiltinTemplates() {
   return [
     template("ralph-demo"),
+    template("coverage-demo"),
     template("experiment-demo"),
     template("pipeline-demo"),
     template("superintendent-demo")
@@ -86094,7 +86735,7 @@ import path111 from "node:path";
 import { readFile as readFile47 } from "node:fs/promises";
 function registerHarnessCommand(program, container) {
   const harness = program.command("harness").description("Run and manage agent harness pairs.");
-  harness.command("run").description("Run a harness pair.").argument("[md-path]", "Path to the harness .md file").option("-y, --yes", "Accept defaults without prompting.").action(async (mdPath, options) => {
+  harness.command("run").description("Run a harness pair.").argument("[md-path]", "Path to the harness .md file").option("--snapshot-path <path>", "File to write/read harness snapshots.").option("--resume", "Resume from the snapshot file when it exists.").option("-y, --yes", "Accept defaults without prompting.").action(async (mdPath, options) => {
     await executeHarnessRun(program, container, mdPath, options);
   });
   harness.command("new").description("Scaffold a harness pair from a built-in template.").argument("<kind>", "Built-in template kind").argument("<basename>", "New harness basename").option("--dir <path>", "Output directory for the harness pair").option("-y, --yes", "Accept defaults without prompting.").action(async (kind, basename4, options) => {
@@ -86108,16 +86749,113 @@ async function executeHarnessRun(program, container, mdPath, options) {
   const flags = resolveHarnessFlags(program, options.yes);
   const resources = createExecutionResources(container, flags, "harness:run");
   const selectedPath = mdPath ? path111.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, flags.assumeYes)).mdPath;
+  const snapshotPath = resolveRunSnapshotPath(container, selectedPath, options.snapshotPath);
+  await prepareHarnessSnapshot(container, selectedPath, snapshotPath, Boolean(options.resume));
   resources.logger.intro("harness run");
+  const baseMessage = `Running ${formatDisplayPath2(container, selectedPath)}`;
+  const progress = createSnapshotProgressReader(container, snapshotPath);
   const result = await withSpinner({
-    message: `Running ${formatDisplayPath2(container, selectedPath)}`,
+    message: () => formatRunMessage(baseMessage, progress.current()),
     fn: () => runHarnessPair(selectedPath, {
-      modulesFor: (frontmatter, meta) => createHarnessModules(container, frontmatter, meta)
+      modulesFor: (frontmatter, meta) => createHarnessModules(container, frontmatter, meta),
+      resume: Boolean(options.resume),
+      snapshotPath
     }),
     stopMessage: () => `Ran ${formatDisplayPath2(container, selectedPath)}`
   });
   resources.logger.info(JSON.stringify(result, null, 2));
 }
+function resolveRunSnapshotPath(container, mdPath, snapshotPath) {
+  if (snapshotPath !== void 0) {
+    return path111.resolve(container.env.cwd, snapshotPath);
+  }
+  const basename4 = path111.basename(mdPath, path111.extname(mdPath));
+  return path111.join(container.env.cwd, ".poe-code", "harnesses", basename4, "snapshot.json");
+}
+async function prepareHarnessSnapshot(container, mdPath, snapshotPath, resumeRequested) {
+  const snapshotExists = await pathExists10(container, snapshotPath);
+  if (!resumeRequested) {
+    return;
+  }
+  if (!snapshotExists) {
+    return;
+  }
+  const [snapshotSource, scriptSource] = await Promise.all([
+    container.fs.readFile(snapshotPath, "utf8"),
+    container.fs.readFile(resolveAjsPath(mdPath), "utf8")
+  ]);
+  try {
+    restore(JSON.parse(snapshotSource), { source: scriptSource });
+  } catch (error3) {
+    if (error3 instanceof Error && error3.message.includes("source changed since snapshot was taken")) {
+      throw new ValidationError(
+        `Cannot resume harness from ${formatDisplayPath2(container, snapshotPath)}: source changed since the snapshot was taken. The .ajs script was edited; start a fresh run without --resume to discard the old snapshot.`
+      );
+    }
+    throw error3;
+  }
+}
+function createSnapshotProgressReader(container, snapshotPath) {
+  let progress;
+  let lastReadStartedAt = 0;
+  return {
+    current() {
+      const now = Date.now();
+      if (now - lastReadStartedAt > 750) {
+        lastReadStartedAt = now;
+        void readSnapshotProgress(container, snapshotPath).then((next) => {
+          if (next !== void 0) {
+            progress = next;
+          }
+        });
+      }
+      return progress;
+    }
+  };
+}
+async function readSnapshotProgress(container, snapshotPath) {
+  try {
+    const parsed = JSON.parse(await container.fs.readFile(snapshotPath, "utf8"));
+    const step2 = readSnapshotStep(parsed);
+    return step2 === void 0 ? void 0 : `step ${step2}`;
+  } catch {
+    return void 0;
+  }
+}
+function readSnapshotStep(snapshot2) {
+  if (typeof snapshot2 !== "object" || snapshot2 === null) {
+    return void 0;
+  }
+  const record = snapshot2;
+  for (const key2 of ["step", "currentStep", "currentAstNodeId"]) {
+    const value = record[key2];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function formatRunMessage(baseMessage, progress) {
+  return progress === void 0 ? baseMessage : `${baseMessage} (${progress})`;
+}
+function resolveAjsPath(mdPath) {
+  const parsed = path111.parse(mdPath);
+  return path111.join(parsed.dir, `${parsed.name}.ajs`);
+}
+async function pathExists10(container, targetPath) {
+  try {
+    await container.fs.stat(targetPath);
+    return true;
+  } catch (error3) {
+    if (hasErrorCode7(error3, "ENOENT")) {
+      return false;
+    }
+    throw error3;
+  }
+}
+function hasErrorCode7(error3, code) {
+  return typeof error3 === "object" && error3 !== null && "code" in error3 && error3.code === code;
+}
 async function executeHarnessNew(program, container, kind, basename4, options) {
   const flags = resolveHarnessFlags(program, options.yes);
   const resources = createExecutionResources(container, flags, "harness:new");
@@ -86263,17 +87001,6 @@ async function assertFilesDoNotExist(container, filePaths) {
     }
   }
 }
-async function pathExists10(container, filePath) {
-  try {
-    await container.fs.stat(filePath);
-    return true;
-  } catch (error3) {
-    if (error3 && typeof error3 === "object" && "code" in error3 && error3.code === "ENOENT") {
-      return false;
-    }
-    throw error3;
-  }
-}
 function createHarnessModules(container, frontmatter, meta) {
   const harnessMeta = {
     kind: meta.kind,
@@ -86688,7 +87415,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.220",
+      version: "3.0.221",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -86763,7 +87490,8 @@ var init_package2 = __esm({
         "codegen:plan-schemas": "tsx scripts/generate-plan-schemas.ts",
         "codegen:harness-schemas": "tsx scripts/generate-harness-schemas.ts",
         "smoke:toolcraft-standalone": "node scripts/verify-toolcraft-standalone.mjs",
-        "sync-skills": "tsx scripts/sync-skills.ts"
+        "sync-skills": "tsx scripts/sync-skills.ts",
+        postinstall: "node scripts/postinstall-sync-skills.mjs"
       },
       bin: {
         poe: "dist/bin.cjs",
@@ -86784,6 +87512,7 @@ var init_package2 = __esm({
         "packages/config-mutations/dist",
         "packages/design-system/dist",
         "packages/memory/dist",
+        "scripts/postinstall-sync-skills.mjs",
         "packages/superintendent/dist",
         "packages/tiny-stdio-mcp-server/dist"
       ],