ace-handbook-integration-pi 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e1e1f851408ab94551b1f23f43b258fdd064b8df2790f0bb2a80ab05363983a
-  data.tar.gz: 7fa298d85b1ce4844320dc980d323b28079c2a05a37dd26ea3dc46d159a41f47
+  metadata.gz: 9a4d798b4819221f1fc95c725700fc5911859b62a197ce3973389d18e208f6d4
+  data.tar.gz: 66c216a3a9c9ebd4164b1e6ea2e3d096b0e0f4468d3efc9ebb7941e6f652be47
 SHA512:
-  metadata.gz: 75c4ed2da5fce4f238a8e8d7b401ee4ac524548f15fb3e5f574a9bd5f526f7b73eecbefc80241e814e6ac71d055253e619dffb2c87443b8c949f94b34ce304d1
-  data.tar.gz: 53bff4c326bad616aff1ddfcf417d16496cd3177f38c6cb35c95d40b2bd5fdcbe6b923883e55241af306c5f03671b96d1538dd2c244417af5928b96fd769560c
+  metadata.gz: 1b2818ac03f7a22254d4247ae0a6374e738dbdad853ebf06d08c92c76619bc746ed0d9365f42590d1057322bdede120459ec6de718b795cd702182f24a1d3047
+  data.tar.gz: 8b31425debbb283d7694fbb8e38222271f55762f4eae14c59f84e3719d97d41b96d85e6921605e5c14e76a1564b4593513324fa5d65a3f8518794343d8f79533

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to ace-handbook-integration-pi will be documented in this fi
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-10-23
+
+### Added
+
+- Add durable in-process semantic eyes, coalescing, explicit deadlines, bounded budgets and actual Pi notification acceptance; retire the actor’s old loops when enabled.
+
 
 ## [0.6.0] - 2026-10-20
 

data/handbook/extensions/ace-wake/index.js

@@ -18,6 +18,7 @@
 
 import { clearInterval, setInterval } from "node:timers";
 
+import { registerEyes } from "./wake/eyes-runtime.js";
 import { WakeDispatcher } from "./wake/wake-dispatcher.js";
 import { parseWakeCommand } from "./wake/wake-command-parser.js";
 import { createLoopPort } from "./wake/loop-subscription.js";
@@ -47,6 +48,7 @@ export default function (pi, ports = {}) {
   /** @type {{registry: WakeRegistry} | undefined} */
   let runtime;
 
+  let eyes;
   const getRuntime = () => runtime;
   const bindRuntime = (ctx) => {
     runtime?.registry.dispose();
@@ -57,6 +59,9 @@ export default function (pi, ports = {}) {
   pi.registerCommand("loop", {
     description: "Manage named timer loops that wake this agent (add | list | remove)",
     handler: async (args, ctx) => {
+      if (eyes.active() && args.trim().startsWith("add")) {
+        ctx.ui?.notify?.("Legacy loops are retired while eyes owns observation", "error"); return;
+      }
       await handleCommand(ctx, "loop", args, getRuntime, bindRuntime);
     },
   });
@@ -64,6 +69,9 @@ export default function (pi, ports = {}) {
   pi.registerCommand("watch", {
     description: "Manage named file watches that wake this agent (add | list | remove)",
     handler: async (args, ctx) => {
+      if (eyes.active() && args.trim().startsWith("add")) {
+        ctx.ui?.notify?.("Legacy watches are retired while eyes owns observation", "error"); return;
+      }
       await handleCommand(ctx, "watch", args, getRuntime, bindRuntime);
     },
   });
@@ -78,6 +86,16 @@ export default function (pi, ports = {}) {
     bindRuntime(ctx);
   });
 
+  eyes = registerEyes(pi, { ...ports.eyes,
+    retireLegacy: () => {
+      if (!runtime) return;
+      const list = runtime.registry.list();
+      for (const entry of list) {
+        if (entry.kind === "loop") runtime.registry.removeLoop(entry.name);
+        else runtime.registry.removeWatch(entry.name);
+      }
+    } });
+
   // A run has begun: wakes dispatched concurrently during the idle-to-running
   // transition can now enter the follow-up queue safely, so the registry
   // drains anything it serialized.

data/handbook/extensions/ace-wake/wake/eyes-runtime.js

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { Eyes, EYES_ENTRY } from "./eyes.js";
+
+const execute = promisify(execFile);
+
+/** Existing native sync owns canonical import; HITL owns event projection.
+ * No Ruby parsing, private text, shell command strings or model work here. */
+export async function observeHitl(cwd, config) {
+  const options = { cwd, timeout: config.timeoutMs, maxBuffer: 1024 * 1024, encoding: "utf8" };
+  for (const route of config.syncRoutes) {
+    const { stdout } = await execute("ace-hitl-hermes", ["sync", "--config", route], options);
+    const result = JSON.parse(stdout);
+    if (!Array.isArray(result.errors) || result.errors.length) throw new Error("Native synchronization incomplete");
+  }
+  const { stdout } = await execute("ace-overseer", ["observe", "--owner", config.recipient, "--scope", config.scope, "--limit", String(config.maxEvents)], options);
+  return JSON.parse(stdout);
+}
+
+export function registerEyes(pi, { retireLegacy, observe = observeHitl, now = Date.now,
+  schedule = (fn, ms) => setInterval(fn, ms), cancel = clearInterval } = {}) {
+  let eyes, timer, attempt, compacting = false, running = false;
+  const stopTimer = () => { if (timer !== undefined) cancel(timer); timer = undefined; };
+  function arm() {
+    stopTimer();
+    if (eyes?.s.enabled && !eyes.s.retired && !eyes.s.breaker) {
+      timer = schedule(() => { void eyes.tick(); }, eyes.s.config.intervalSeconds * 1000);
+      timer?.unref?.();
+    }
+  }
+  const bind = (ctx) => {
+    stopTimer(); eyes?.dispose(); attempt = undefined; compacting = false; running = false;
+    const entries = ctx.sessionManager.getBranch();
+    const snapshot = [...entries].reverse().find((e) => e.type === "custom" && e.customType === EYES_ENTRY)?.data;
+    if (snapshot?.enabled || snapshot?.retired) retireLegacy?.();
+    const ownerCwd = path.resolve(ctx.cwd);
+    if (snapshot?.ownerCwd && snapshot.ownerCwd !== ownerCwd) {
+      eyes = undefined;
+      ctx.ui?.setStatus?.("ace-eyes", "eyes blocked: session belongs to another project cwd");
+      throw new Error("Eyes project owner mismatch; preserve this actor and use its original project session");
+    }
+    eyes = new Eyes({ snapshot, now,
+      save: (data) => pi.appendEntry(EYES_ENTRY, { ...data, ownerCwd }),
+      status: (state) => {
+        ctx.ui?.setStatus?.("ace-eyes", `eyes ${state.retired ? "retired" : state.breaker?.reason || (state.enabled ? "observing" : "off")} pending:${state.pending}`);
+        if (state.breaker || state.retired) stopTimer();
+      },
+      observe: (config) => observe(ctx.cwd, config),
+      canDeliver: () => !compacting && (ctx.isIdle() || running),
+      deliveryStatus: () => {
+        if (attempt?.accepted) return "accepted";
+        // sendUserMessage is a void wrapper. Busy/queued is uncertain, not
+        // acceptance or rejection. Idle without confirmation is uncertain:
+        // async input/auth preflight may still be running, so never blind-retry.
+        return compacting || !ctx.isIdle() || ctx.hasPendingMessages() ? "waiting" : "uncertain";
+      },
+      deliver: async (batch) => {
+        if (!ctx.model) return false;
+        const text = `[ace-eyes] Pending canonical HITL/deadline revisions: ${JSON.stringify(batch)}. ` +
+          "Read original events; adopt reports through ace-overseer process-reports and existing task/assignment gates. " +
+          "Reconcile uncertain effects; never repeat external actions on wake alone. After handling each exact revision, " +
+          "acknowledge with the ace_eyes tool (action ack, key, revision). Settlement alone is not acknowledgement.";
+        attempt = { text, accepted: false };
+        const result = pi.sendUserMessage(text, { deliverAs: "followUp" });
+        // Some hosts expose a promise, the standard ExtensionAPI exposes void.
+        // Neither completion nor void is proof of message consumption.
+        if (result?.then) await result;
+        return result !== false;
+      } });
+    if (eyes.s.enabled || eyes.s.retired) retireLegacy?.();
+    arm();
+    if (eyes.s.enabled) void eyes.tick();
+  };
+  pi.on("session_start", async (_event, ctx) => bind(ctx));
+  pi.on("session_tree", async (_event, ctx) => bind(ctx));
+  pi.on("agent_start", async () => { running = true; });
+  pi.on("agent_settled", async () => { running = false; });
+  pi.on("message_start", async (event) => {
+    if (event.message?.role !== "user" || !attempt) return;
+    const text = typeof event.message.content === "string" ? event.message.content :
+      (event.message.content || []).filter(part => part.type === "text").map(part => part.text).join("");
+    if (text === attempt.text) attempt.accepted = true;
+  });
+  pi.on("session_before_compact", async (event) => { if (event.reason === "manual") compacting = true; });
+  pi.on("session_compact", async () => { compacting = false; eyes?.persist(); });
+  pi.on("session_compact_failed", async () => { compacting = false; });
+  pi.on("session_shutdown", async () => { stopTimer(); eyes?.dispose(); });
+  pi.on("message_end", async (event) => {
+    const message = event.message;
+    if (message?.role === "assistant" && message.stopReason === "error") eyes?.quota(message.errorMessage);
+  });
+  pi.registerTool?.({
+    name: "ace_eyes", label: "Eyes acknowledgement", description: "Read pending semantic events or acknowledge an exact handled revision. Does not accept reports, authorize effects, start actors or reset quota. Use existing report/assignment owners first. Deadlines require an operation identity and revision; cancel when no longer active.",
+    parameters: { type: "object", properties: {
+      action: { type: "string", enum: ["status", "ack", "deadline", "cancel"] },
+      key: { type: "string" }, revision: { type: "string" }, at: { type: "integer" }
+    }, required: ["action"], additionalProperties: false },
+    execute: async (_id, args, _signal, _onUpdate, ctx) => {
+      if (!eyes) {
+        if (!ctx) throw new Error("Eyes session not initialized");
+        bind(ctx);
+      }
+      if (args.action === "ack") eyes.ack(args.key, args.revision);
+      else if (args.action === "deadline") eyes.deadline(args.key, args.at, args.revision);
+      else if (args.action === "cancel") eyes.cancelDeadline(args.key);
+      else if (args.action !== "status") throw new Error("Unknown eyes action");
+      // Do not send a second wake from inside the running model turn. The next
+      // observation delivers remaining coalesced revisions through the same owner.
+      const details = { ...eyes.summary(), pending: eyes.s.pending, deadlines: eyes.s.deadlines };
+      return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+    }
+  });
+  pi.registerCommand("eyes", { description: "Event-driven HITL observation: start CONFIG | status | ack KEY REV | deadline NAME REVISION EPOCH_MS | cancel NAME | resume quota-verified | retire",
+    handler: async (args, ctx) => {
+      try {
+        if (!eyes) bind(ctx);
+        const [command, a, b, ...rest] = args.trim().split(/\s+/);
+        if (rest.length && command !== "deadline") throw new Error("Too many arguments");
+        switch (command) {
+          case "start": {
+            if (!a || b) throw new Error("Use eyes start CONFIG_JSON");
+            const config = JSON.parse(fs.readFileSync(path.resolve(ctx.cwd, a), "utf8"));
+            eyes.start(config); retireLegacy?.(); arm(); await eyes.tick(); break;
+          }
+          case "status": ctx.ui?.notify?.(JSON.stringify({ ...eyes.summary(), pending: eyes.s.pending, deadlines: eyes.s.deadlines }), "info"); break;
+          case "ack": eyes.ack(a, b); await eyes.tick(); break;
+          case "deadline":
+            if (rest.length !== 1) throw new Error("Deadline requires operation identity, revision and epoch milliseconds");
+            eyes.deadline(a, Number(rest[0]), b); await eyes.tick(); break;
+          case "cancel": eyes.cancelDeadline(a); break;
+          case "resume":
+            if (a !== "quota-verified" || b) throw new Error("Explicit owner verification required: eyes resume quota-verified");
+            await eyes.resume(); arm(); break;
+          case "retire": eyes.retire(); retireLegacy?.(); stopTimer(); break;
+          default: throw new Error("Unknown eyes command; use start, status, ack, deadline, cancel, resume or retire");
+        }
+      } catch (error) {
+        // Never echo process stdout/stderr: a failed native sync may carry private data.
+        ctx.ui?.notify?.(`Eyes operation refused (${error.name}); check configuration or /eyes status`, "error");
+      }
+    } });
+  return { active: () => Boolean(eyes?.s.enabled || eyes?.s.retired) };
+}

data/handbook/extensions/ace-wake/wake/eyes.js

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+export const EYES_ENTRY = "ace-wake-eyes";
+export const defaults = { intervalSeconds: 30, maxEvents: 500, maxObservationsPerHour: 120, maxWakesPerHour: 20,
+  timeoutMs: 10000, maxErrors: 3, maxPending: 2000, scope: "current", recipient: "self", syncRoutes: [] };
+
+export function validateConfig(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input) ||
+      Object.keys(input).some(key => !(key in defaults))) throw new Error("Invalid eyes configuration");
+  const config = { ...defaults, ...input };
+  for (const [key, min, max] of [["intervalSeconds", 1, 3600], ["maxEvents", 1, 2000],
+    ["maxObservationsPerHour", 1, 3600], ["maxWakesPerHour", 1, 1000], ["timeoutMs", 100, 30000], ["maxErrors", 1, 10], ["maxPending", 1, 10000]]) {
+    if (!Number.isInteger(config[key]) || config[key] < min || config[key] > max) throw new Error(`Invalid ${key}`);
+  }
+  if (typeof config.recipient !== "string" || !/^[a-zA-Z0-9_-]{1,64}$/.test(config.recipient)) throw new Error("Invalid observer recipient");
+  if (!["current", "all"].includes(config.scope) || !Array.isArray(config.syncRoutes) || config.syncRoutes.length > 10 ||
+      config.syncRoutes.some((p) => typeof p !== "string" || !p.startsWith("/"))) throw new Error("Invalid eyes sources");
+  return config;
+}
+
+/** Observation/delivery bookkeeping in the existing Pi session, not a work
+ * queue. It never starts tasks or accepts reports on behalf of their owner. */
+export class Eyes {
+  constructor({ snapshot, save, observe, deliver, now = Date.now, status = () => {}, deliveryStatus = () => "accepted", canDeliver = () => true }) {
+    this.s = structuredClone(snapshot || { enabled: false, retired: false, config: defaults,
+      pending: {}, acknowledged: {}, deadlines: {}, breaker: null, errors: 0, window: null });
+    this.s.config = validateConfig(this.s.config);
+    for (const key of ["pending", "acknowledged", "deadlines"])
+      if (!this.s[key] || typeof this.s[key] !== "object" || Array.isArray(this.s[key])) throw new Error("Invalid persisted eyes state");
+    if (typeof this.s.enabled !== "boolean" || typeof this.s.retired !== "boolean" ||
+        !Number.isInteger(this.s.errors) || this.s.errors < 0) throw new Error("Invalid persisted eyes state");
+    this.save = save; this.observe = observe; this.deliver = deliver; this.now = now; this.status = status;
+    this.deliveryStatus = deliveryStatus; this.canDeliver = canDeliver;
+    this.busy = false; this.disposed = false;
+    // A process restart does not imply receipt acknowledgement. Reconcile the
+    // same pending revisions; business-effect idempotence remains with .5.4.
+    this.inflight = false;
+    this.sent = new Map();
+    this.generation = 0;
+  }
+  persist() { this.save(structuredClone(this.s)); this.status(this.summary()); }
+  summary() { return { enabled: this.s.enabled, retired: this.s.retired, pending: Object.keys(this.s.pending).length,
+    breaker: this.s.breaker, errors: this.s.errors, observations: this.s.window?.count || 0, wakes: this.s.window?.wakes || 0 }; }
+  start(config) {
+    if (this.s.retired) throw new Error("Retired actor cannot restart its eyes; hand off pending to its owner");
+    if (this.s.breaker) throw new Error("Resolve breaker with explicit resume first");
+    this.s.config = validateConfig(config); this.s.enabled = true; this.persist();
+  }
+  block(reason) {
+    if (!this.s.breaker) { this.s.breaker = { reason, at: this.now() }; this.persist(); }
+  }
+  async resume() {
+    if (this.s.retired) throw new Error("Retired actor cannot resume");
+    // Explicit operator action; check source/transport readiness without a model
+    // request. Quota availability must have been verified by the owner.
+    const result = await this.observe(this.s.config);
+    this.validate(result);
+    this.s.breaker = null; this.s.errors = 0; this.s.window = null; this.inflight = false;
+    this.s.enabled = true; this.persist();
+    await this.tick();
+  }
+  retire() { this.generation++; this.s.enabled = false; this.s.retired = true; this.persist(); }
+  dispose() { this.disposed = true; this.generation++; }
+  quota(message) {
+    if (/quota|insufficient.?(?:credit|balance)|billing.?limit|budget.?exceed|usage.?limit|rate.?limit|\b429\b/i.test(String(message))) this.block("quota-or-budget");
+  }
+  deadline(name, at, operationRevision) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name) || !Number.isSafeInteger(at) || at < 0 || typeof operationRevision !== "string" || !/^[a-zA-Z0-9._:-]{1,128}$/.test(operationRevision)) throw new Error("Invalid deadline");
+    const key = `deadline:${name}`;
+    delete this.s.pending[key];
+    this.sent.delete(key); this.inflight = this.sent.size > 0;
+    this.s.deadlines[name] = { at, operationRevision }; this.persist();
+  }
+  cancelDeadline(name) {
+    delete this.s.deadlines[name]; delete this.s.pending[`deadline:${name}`];
+    this.sent.delete(`deadline:${name}`); this.inflight = this.sent.size > 0; this.persist();
+  }
+  ack(key, revision) {
+    if (this.s.pending[key]?.revision !== revision && this.sent.get(key) !== revision)
+      throw new Error("Ack does not match an observed pending or delivered revision");
+    this.s.acknowledged[key] = revision;
+    if (this.s.pending[key]?.revision === revision) delete this.s.pending[key];
+    this.sent.delete(key);
+    this.inflight = this.sent.size > 0; this.persist();
+  }
+  validate(result) {
+    if (result?.schema !== "ace.hitl.observation/v1" || !Array.isArray(result.events) || result.events.length > this.s.config.maxEvents)
+      throw new Error("Invalid or over-budget HITL observation");
+    if (result.settled !== undefined && !Array.isArray(result.settled)) throw new Error("Invalid settlement projection");
+    const rows = [...result.events, ...(result.settled || [])];
+    if (rows.length > this.s.config.maxEvents) throw new Error("Over-budget projection");
+    const keys = new Set();
+    for (const event of rows) {
+      if (!/^[a-f0-9]{64}$/.test(event.key) || !/^[a-f0-9]{64}$/.test(event.revision) ||
+          typeof event.id !== "string" || !/^[a-z0-9_-]{1,64}$/i.test(event.id) || keys.has(event.key)) throw new Error("Invalid event identity");
+      keys.add(event.key);
+    }
+  }
+  async tick() {
+    if (this.busy || this.disposed || !this.s.enabled || this.s.retired || this.s.breaker) return;
+    const now = this.now();
+    if (!this.s.window || now - this.s.window.start >= 3600000) this.s.window = { start: now, count: 0, wakes: 0 };
+    if (this.s.window.count >= this.s.config.maxObservationsPerHour) { this.block("observation-budget"); return; }
+    this.s.window.count++; this.persist(); // Budget survives restart too.
+    this.busy = true;
+    const generation = this.generation;
+    try {
+      const result = await this.observe(this.s.config);
+      if (generation !== this.generation || this.disposed) return;
+      this.validate(result);
+      for (const e of result.settled || []) {
+        this.s.acknowledged[e.key] = e.revision;
+        if (this.s.pending[e.key]?.revision === e.revision) delete this.s.pending[e.key];
+        this.sent.delete(e.key);
+      }
+      if (this.inflight && this.sent.size === 0) this.inflight = false;
+      for (const e of result.events) {
+        if (this.s.acknowledged[e.key] !== e.revision) this.s.pending[e.key] = { id: e.id, revision: e.revision };
+      }
+      for (const [name, deadline] of Object.entries(this.s.deadlines)) {
+        const { at, operationRevision } = deadline;
+        const key = `deadline:${name}`, revision = hash([name, at, operationRevision]);
+        if (now >= at && this.s.acknowledged[key] !== revision) this.s.pending[key] = { id: name, revision };
+      }
+      if (Object.keys(this.s.pending).length + Object.keys(this.s.acknowledged).length > this.s.config.maxPending) {
+        this.block("retention-budget"); return;
+      }
+      this.persist();
+      if (this.inflight && this.deliveryStatus() === "uncertain") {
+        this.block("notification-unconfirmed"); return;
+      }
+      if (!this.inflight && !this.s.breaker && Object.keys(this.s.pending).length && this.canDeliver()) {
+        // Retain identities before attempting delivery. A rejected send leaves
+        // pending intact; acceptance by Pi is not application acknowledgement.
+        if ((this.s.window.wakes || 0) >= this.s.config.maxWakesPerHour) { this.block("wake-budget"); return; }
+        this.s.window.wakes = (this.s.window.wakes || 0) + 1;
+        this.persist(); // Includes uncertain notification attempts, never token billing.
+        const batch = Object.entries(this.s.pending).slice(0, 20);
+        this.inflight = Boolean(await this.deliver(batch));
+        if (this.inflight) this.sent = new Map(batch.map(([key, value]) => [key, value.revision]));
+        if (!this.inflight) throw new Error("wake delivery refused");
+      }
+      if (this.s.errors && (!this.inflight || this.deliveryStatus() === "accepted")) { this.s.errors = 0; this.persist(); }
+    } catch {
+      this.s.errors++; this.persist();
+      if (this.s.errors >= this.s.config.maxErrors) this.block("observation-or-delivery-failure");
+    } finally { this.busy = false; }
+  }
+}

data/lib/ace/handbook/integration/pi/version.rb

@@ -4,7 +4,7 @@ module Ace
   module Handbook
     module Integration
       module Pi
-        VERSION = "0.6.0"
+        VERSION = "0.7.0"
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-handbook-integration-pi
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-handbook
@@ -23,6 +23,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.33'
+- !ruby/object:Gem::Dependency
+  name: ace-overseer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+- !ruby/object:Gem::Dependency
+  name: ace-hitl-hermes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
 description: PI-specific provider integration package that extends ace-handbook with
   provider manifests.
 email:
@@ -36,6 +64,8 @@ files:
 - README.md
 - handbook/extensions/ace-wake/index.js
 - handbook/extensions/ace-wake/package.json
+- handbook/extensions/ace-wake/wake/eyes-runtime.js
+- handbook/extensions/ace-wake/wake/eyes.js
 - handbook/extensions/ace-wake/wake/inbox-discovery.js
 - handbook/extensions/ace-wake/wake/loop-subscription.js
 - handbook/extensions/ace-wake/wake/types.js