@agentshouse/kit 0.1.0-alpha.25 → 0.1.0-alpha.27

package/src/tasks.js

@@ -0,0 +1,72 @@
+import { setTimeout as delay } from "node:timers/promises";
+
+export function coalescedTask(signal, fail, work) {
+  let pending = false;
+  let task = null;
+  const trigger = () => {
+    pending = true;
+    if (task !== null) return;
+    task = (async () => {
+      while (pending && !signal.aborted) {
+        pending = false;
+        await work();
+      }
+    })()
+      .catch((error) => {
+        if (signal.aborted) return;
+        fail(error);
+      })
+      .finally(() => {
+        task = null;
+        if (pending && !signal.aborted) trigger();
+      });
+  };
+  return { trigger, idle: () => task === null, settled: () => task };
+}
+
+export function residentWake() {
+  let pending = false;
+  let release = null;
+  return {
+    notify() {
+      pending = true;
+      release?.();
+    },
+    async wait(milliseconds, signal) {
+      if (pending) {
+        pending = false;
+        return;
+      }
+      const pause = new AbortController();
+      try {
+        await Promise.race([
+          new Promise((resolve) => {
+            release = resolve;
+          }),
+          delay(milliseconds, undefined, { signal: AbortSignal.any([signal, pause.signal]) }),
+        ]);
+      } catch (error) {
+        if (!signal.aborted) throw error;
+      } finally {
+        release = null;
+        pending = false;
+        pause.abort();
+      }
+    },
+  };
+}
+
+const turns = new Map();
+
+export function exclusively(path, work) {
+  const turn = (turns.get(path) ?? Promise.resolve()).then(work);
+  const settled = turn.then(
+    () => undefined,
+    () => undefined,
+  );
+  turns.set(path, settled);
+  void settled.then(() => {
+    if (turns.get(path) === settled) turns.delete(path);
+  });
+  return turn;
+}

package/src/worker.js

@@ -1,5 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
@@ -17,9 +18,11 @@ import { retryConversationFiles } from "./conversation-originals.js";
 import { openAssistantDrafts } from "./draft.js";
 import { localRequest, reconcileInbound } from "./inbound.js";
 import { localFiles } from "./local-files.js";
-import { answerText, answerYaml } from "./mcp.js";
+import { answerText, answerYaml, editRefusal } from "./mcp.js";
 import { inheritedEnvironment } from "./command.js";
+import { sourceEntries } from "./google/entries.js";
 import { watchKitWork } from "./kit-work-stream.js";
+import { coalescedTask, residentWake } from "./tasks.js";
 import {
   applyWorkingCopies,
   deliverWorkingCopies,
@@ -84,6 +87,7 @@ import {
 import { operationId } from "./operation.js";
 import { runSetup, signInWantedAgent } from "./setup.js";
 import { readSettlements, removeSettlement, writeSettlement } from "./settlement.js";
+import { howWeWorkOwed, noteHowWeWork, reconcileSkillSet } from "./skill-set.js";
 import { writeText } from "./state.js";
 import { failedReport, terminalReport } from "./terminal.js";
 import {
@@ -285,13 +289,12 @@ function endOnEpochReport(ended, act) {
 }
 
 function refusedWith(text) {
-  const conflicts = answerYaml(text.slice(text.indexOf("\n") + 1))?.conflicts;
-  const current = Array.isArray(conflicts)
-    ? conflicts.map(({ path, state, revision }) =>
-        state === "absent" ? { path, revision: null, content: null } : { path, revision },
-      )
-    : null;
-  return { refused: { code: text.split(":")[0].trim(), text, current } };
+  const { code, conflicts } = editRefusal(text);
+  const current =
+    conflicts?.map(({ path, state, revision }) =>
+      state === "absent" ? { path, revision: null, content: null } : { path, revision },
+    ) ?? null;
+  return { refused: { code, text, current } };
 }
 
 function acceptedWith(text) {
@@ -389,6 +392,10 @@ async function openRunBridge(context, bound, authority, start) {
     start,
     question: handed((batch) => admitInteraction(context.session, bound.session, batch)),
     plan: handed((snapshot) => admitPlanSnapshot(context.session, bound.session, snapshot)),
+    howWeWork: () =>
+      noteHowWeWork(context.directory).catch((error) =>
+        reported(`How-we-work note unwritable (${error.code ?? "unknown"})`),
+      ),
     interrupt: handed((interrupt, outcome) =>
       reportInterruptOutcome(context.session, interrupt, outcome),
     ),
@@ -576,6 +583,7 @@ async function prepareAssignment(context, assignment, resumed) {
   const authority = { token: assignment.session.token, expiresAt: assignment.session.expiresAt };
   const start = {
     base_instructions: assignment.baseInstructions,
+    create_how_we_work: await howWeWorkOwed(context.directory),
     working_directory: assignment.workingDirectory,
     working_copies: await appliedWorkingCopies(context),
     execution_authority: context.configuration.executionAuthority,
@@ -855,6 +863,7 @@ async function workerContext(options, dependencies, resident = false) {
     launchBase: launchBase(dependencies),
     container: dependencies.container ?? process.env.HOUSE_KIT_CONTAINER === "1",
     directory: options.directory,
+    home: dependencies.home ?? homedir(),
     files: { originals: [], failures: [] },
     epochReport: null,
     agentRefresh: Promise.resolve(),
@@ -903,6 +912,11 @@ function queueAgentRefresh(context, dependencies, signal, configuration, pointer
 async function controlledPass(context, dependencies, configuration, signal) {
   context.signal = signal;
   context.session.signal = signal;
+  await reconcileSkillSet({
+    directory: context.directory,
+    home: context.home,
+    accepted: configuration.skills,
+  });
   context.busy = true;
   try {
     return await afterEpochReport(context, () => workerPass(context, dependencies, configuration));
@@ -943,62 +957,6 @@ async function reportedWorkingCopies(act, context, signal) {
   }
 }
 
-function coalescedTask(signal, fail, work) {
-  let pending = false;
-  let task = null;
-  const trigger = () => {
-    pending = true;
-    if (task !== null) return;
-    task = (async () => {
-      while (pending && !signal.aborted) {
-        pending = false;
-        await work();
-      }
-    })()
-      .catch((error) => {
-        if (signal.aborted) return;
-        fail(error);
-      })
-      .finally(() => {
-        task = null;
-        if (pending && !signal.aborted) trigger();
-      });
-  };
-  return { trigger, idle: () => task === null, settled: () => task };
-}
-
-function residentWake() {
-  let pending = false;
-  let release = null;
-  return {
-    notify() {
-      pending = true;
-      release?.();
-    },
-    async wait(milliseconds, signal) {
-      if (pending) {
-        pending = false;
-        return;
-      }
-      const pause = new AbortController();
-      try {
-        await Promise.race([
-          new Promise((resolve) => {
-            release = resolve;
-          }),
-          delay(milliseconds, undefined, { signal: AbortSignal.any([signal, pause.signal]) }),
-        ]);
-      } catch (error) {
-        if (!signal.aborted) throw error;
-      } finally {
-        release = null;
-        pending = false;
-        pause.abort();
-      }
-    },
-  };
-}
-
 function residentUpdate(context, wake) {
   let requested = existsSync(updateDrain(context.directory));
   let ready = null;
@@ -1066,6 +1024,7 @@ export async function runResident(options, dependencies = {}) {
   const wake = residentWake();
   const update = residentUpdate(context, wake);
   context.update = update;
+  let sources = null;
   const served = await serveResident(
     session,
     context.directory,
@@ -1075,6 +1034,8 @@ export async function runResident(options, dependencies = {}) {
       pushWorkingCopy({ directory: context.directory, session }, request, ownerCaller(session), signal).catch(
         (error) => ({ refused: true, text: formatCommandError(error) }),
       ),
+    (source) =>
+      sources === null ? Promise.reject(new KitRefusal("kit_resident_unavailable")) : sources.capture(source),
   );
   const serve = async (signal) => {
     context.busy = true;
@@ -1137,13 +1098,24 @@ export async function runResident(options, dependencies = {}) {
     const deliveries = coalescedTask(signal, unavailable, () =>
       reportedWorkingCopies(deliverWorkingCopies, context, signal),
     );
+    sources = sourceEntries({
+      session: context.session,
+      directory: context.directory,
+      dependencies,
+      signal: AbortSignal.any([signal, watcher.signal]),
+      now: session.now,
+      draining: () => update.requested,
+      unavailable: (error) => reported(`google sources unavailable: ${error?.message ?? error}`),
+    });
+    await sources.start();
     const pointer = () => {
       if (!update.requested) agentRefresh.trigger();
     };
-    const available = (subject) => {
+    const available = (subject = null) => {
       if (update.requested) return;
-      if (subject !== "working_copy") agentRefresh.trigger();
-      if (subject !== "agents") copies.trigger();
+      if (subject === null || subject === "agents") agentRefresh.trigger();
+      if (subject === null || subject === "working_copy") copies.trigger();
+      if (subject === null || subject === "sources") sources.reconcile();
     };
     context.onIdle = pointer;
     context.workingCopiesApplied = copies.settled;
@@ -1168,7 +1140,12 @@ export async function runResident(options, dependencies = {}) {
           if (sessions.length > 0) update.answer({ ready: false, sessions });
           else if (
             session.refused ||
-            (!served.serving() && logins.size === 0 && agentRefresh.idle() && copies.idle() && deliveries.idle())
+            (!served.serving() &&
+              logins.size === 0 &&
+              agentRefresh.idle() &&
+              copies.idle() &&
+              deliveries.idle() &&
+              sources.idle())
           ) {
             return;
           }
@@ -1182,6 +1159,7 @@ export async function runResident(options, dependencies = {}) {
       await agentRefresh.settled();
       await copies.settled();
       await deliveries.settled();
+      await sources.settled();
       for (const running of logins.values()) running.controller.abort();
       await Promise.all([...logins.values()].map((running) => running.task));
       await context.agentRefresh;

package/src/working-copy.js

@@ -23,6 +23,7 @@ import { readNote, writeNote, writeText } from "./state.js";
 import { bootstrapBundle, discoveryOf, door, withSession } from "./sync.js";
 import { isGeneratedProvenance, sidecarPath, structuredOrReplace } from "./sync-library.js";
 import { locate, removeReplicaFile, writeReplicaFile } from "./sync-state.js";
+import { exclusively } from "./tasks.js";
 
 const COMMITTER_NAME = "House Kit";
 const COMMITTER_EMAIL = "house-kit@localhost";
@@ -366,21 +367,6 @@ async function heldCopies(directory) {
   return held.filter((copy) => copy !== null);
 }
 
-const turns = new Map();
-
-function exclusively(path, work) {
-  const turn = (turns.get(path) ?? Promise.resolve()).then(work);
-  const settled = turn.then(
-    () => undefined,
-    () => undefined,
-  );
-  turns.set(path, settled);
-  void settled.then(() => {
-    if (turns.get(path) === settled) turns.delete(path);
-  });
-  return turn;
-}
-
 function received(scope, read, parents) {
   const files = read.files.filter((file) => file.writable);
   return { message: `House ${housePath(scope)} at position ${read.position}`, parents, files, whole: true };

package/src/google/declared.js

@@ -1,146 +0,0 @@
-import { ITEM_BODY_MAX_BYTES } from "../contract.js";
-import { KitRefusal } from "../refusal.js";
-import { googleJson } from "./gateway.js";
-
-function valueAt(value, path) {
-  let current = value;
-  for (const segment of path.split(".")) {
-    if (current === null || current === undefined || typeof current !== "object") return undefined;
-    current = current[segment];
-  }
-  return current;
-}
-
-function requiredText(value, declaration) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new KitRefusal("google_provider_response_invalid", declaration);
-  }
-  return value;
-}
-
-function optionalText(value, declaration) {
-  if (value === undefined || value === null) return null;
-  return requiredText(value, declaration);
-}
-
-function cursorOf(value) {
-  if (value === null) return { pageToken: null, checkpoint: null };
-  let cursor;
-  try {
-    cursor = JSON.parse(value);
-  } catch {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  if (
-    typeof cursor !== "object" ||
-    cursor === null ||
-    (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    (cursor.checkpoint !== null && typeof cursor.checkpoint !== "string")
-  ) {
-    throw new KitRefusal("google_checkpoint_invalid", "declared service");
-  }
-  return cursor;
-}
-
-function composedBody(item, paths) {
-  const parts = paths.map((path) => valueAt(item, path));
-  if (parts.some((part) => !["string", "number", "boolean"].includes(typeof part))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  const body = parts.map((part) => `${part}`).join("\n\n");
-  if (Buffer.byteLength(body, "utf8") > ITEM_BODY_MAX_BYTES) {
-    throw new KitRefusal("google_provider_response_invalid", "declared body");
-  }
-  return body;
-}
-
-function normalizedItem(service, item) {
-  const fields = service.declaration.fields;
-  const observedAt = requiredText(valueAt(item, fields.observedAt), "declared observed time");
-  if (Number.isNaN(Date.parse(observedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared observed time");
-  }
-  const container = requiredText(valueAt(item, fields.container), "declared container");
-  const nativeVersion =
-    fields.nativeVersion === null
-      ? null
-      : optionalText(valueAt(item, fields.nativeVersion), "declared native version");
-  const providerModifiedAt =
-    fields.providerModifiedAt === null
-      ? null
-      : optionalText(
-          valueAt(item, fields.providerModifiedAt),
-          "declared provider modification time",
-        );
-  if (providerModifiedAt !== null && Number.isNaN(Date.parse(providerModifiedAt))) {
-    throw new KitRefusal("google_provider_response_invalid", "declared provider modification time");
-  }
-  return {
-    namespace: `google/${service.service}`,
-    nativeObjectId: requiredText(valueAt(item, fields.nativeId), "declared native id"),
-    nativeVersion,
-    providerModifiedAt:
-      providerModifiedAt === null ? null : new Date(providerModifiedAt).toISOString(),
-    observedAt: new Date(observedAt).toISOString(),
-    body: composedBody(item, fields.body),
-    author:
-      fields.author === null
-        ? null
-        : optionalText(valueAt(item, fields.author), "declared author"),
-    url:
-      fields.url === null ? null : optionalText(valueAt(item, fields.url), "declared url"),
-    attachments: [],
-    container: `google/${service.service}/${container}`,
-  };
-}
-
-export async function declaredPage(options, dependencies = {}) {
-  const declared = options.service.declaration;
-  const cursor = cursorOf(options.cursor);
-  const url = new URL(declared.path, `https://${declared.host}`);
-  for (const [name, value] of Object.entries(declared.query)) url.searchParams.set(name, value);
-  url.searchParams.set(declared.pageSize, `${options.limit}`);
-  if (cursor.pageToken !== null) {
-    url.searchParams.set(declared.pageToken.request, cursor.pageToken);
-  }
-  if (cursor.checkpoint !== null) {
-    url.searchParams.set(declared.pageToken.checkpointRequest, cursor.checkpoint);
-  }
-  const answer = await googleJson(
-    {
-      directory: options.directory,
-      instance: options.instance,
-      client: options.client,
-      requiredScopes: declared.scopes,
-      url: url.toString(),
-      signal: options.signal,
-    },
-    dependencies,
-  );
-  const entries = valueAt(answer, declared.items);
-  if (!Array.isArray(entries) || entries.length > options.limit) {
-    throw new KitRefusal("google_provider_response_invalid", "declared items");
-  }
-  const pageToken = valueAt(answer, declared.pageToken.response);
-  let next;
-  if (pageToken !== undefined && pageToken !== null) {
-    next = {
-      pageToken: requiredText(pageToken, "declared page token"),
-      checkpoint: cursor.checkpoint,
-    };
-  } else {
-    next = {
-      pageToken: null,
-      checkpoint: requiredText(
-        valueAt(answer, declared.pageToken.checkpointResponse),
-        "declared checkpoint",
-      ),
-    };
-  }
-  return {
-    items: entries.map((entry) => normalizedItem(options.service, entry)),
-    dropped: [],
-    cursor: JSON.stringify(next),
-    more: pageToken !== undefined && pageToken !== null,
-  };
-}

package/src/google/id.js

@@ -1 +0,0 @@
-export const GOOGLE_DRIVE_ID = /^[A-Za-z0-9_-]{1,512}$/;

package/src/instance/google.js

@@ -1 +0,0 @@
-export const GOOGLE_OAUTH_CLIENT = Object.freeze({"id":"911965338518-867gdvuddb7kdkjo3qvpv6gds369alb7.apps.googleusercontent.com","secret":"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"});

package/src/starter-set.js

@@ -1,17 +0,0 @@
-import { cp, mkdir, symlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const AGENTS_INSTRUCTION = "The agents.house `house` CLI is available: run `house --help`.\n";
-const GRILLING_SOURCE = fileURLToPath(new URL("starter-set/grilling/", import.meta.url));
-
-export async function seedStarterSet(target) {
-  await mkdir(target, { recursive: true });
-  await writeFile(join(target, "AGENTS.md"), AGENTS_INSTRUCTION);
-  await symlink("AGENTS.md", join(target, "CLAUDE.md"));
-  const skills = join(target, ".agents", "skills");
-  await mkdir(skills, { recursive: true });
-  await cp(GRILLING_SOURCE, join(skills, "grilling"), { recursive: true });
-  await mkdir(join(target, ".claude"), { recursive: true });
-  await symlink(join("..", ".agents", "skills"), join(target, ".claude", "skills"));
-}