portable-agent-layer 0.91.8 → 0.93.0

package/src/hooks/lib/inference.ts

@@ -23,6 +23,7 @@
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { z } from "zod";
 import {
   getActiveAgent,
   isAntigravity,
@@ -151,7 +152,7 @@ interface InferenceOptions {
   tier?: InferenceTier;
   maxTokens?: number;
   timeout?: number;
-  /** JSON schema for structured output — guarantees valid JSON matching the schema */
+  /** JSON schema the reply must match; a reply that doesn't fails with the reason */
   jsonSchema?: Record<string, unknown>;
   /** Opaque label identifying the calling handler — appears in debug logs as caller=X */
   caller?: string;
@@ -167,7 +168,34 @@ interface InferenceResult {
   usage?: { inputTokens: number; outputTokens: number };
 }
 
+function schemaProblem(
+  output: string,
+  schema: Record<string, unknown>
+): string | undefined {
+  const checked = z.fromJSONSchema(schema).safeParse(parseJsonFromOutput(output));
+  if (checked.success) return undefined;
+  return checked.error.issues
+    .map((issue) => `${issue.path.join(".") || "reply"}: ${issue.message}`)
+    .join("; ");
+}
+
 export async function inference(opts: InferenceOptions): Promise<InferenceResult> {
+  const result = await routeInference(opts);
+  if (!opts.jsonSchema || !result.success || !result.output) return result;
+  const problem = schemaProblem(result.output, opts.jsonSchema);
+  if (!problem) return result;
+  logError(
+    "inference",
+    `caller=${opts.caller ?? "anonymous"} schema mismatch: ${problem}`
+  );
+  return {
+    ...result,
+    success: false,
+    error: `the reply does not match the schema: ${problem}`,
+  };
+}
+
+async function routeInference(opts: InferenceOptions): Promise<InferenceResult> {
   // Hard kill-switch — set by the test suite to guarantee no real inference
   // ever fires from tests (no spawn, no API call). Production code never sets it.
   if (process.env.PAL_INFERENCE_DISABLED === "1") {
@@ -552,8 +580,10 @@ async function inferenceViaAntigravitySpawn(
  *   --disable-builtin-mcps    → no MCP servers in the child (extra safety)
  *   --no-auto-update          → prevent CLI self-update from delaying the spawn
  *   --no-color                → clean stdout for capture
- *   --allow-all-tools         → REQUIRED for non-interactive mode (without it,
- *                                copilot prompts for tool-use confirmation)
+ *   --available-tools=none    → Copilot has no "no tools" flag; an allowlist
+ *                                naming an unknown tool hides every tool
+ *   --deny-tool=…             → backstop: deny rules win over any allow rule
+ *   --silent                  → keeps the tool-filter notices out of stdout
  *
  * Copilot has no --system-prompt flag, so system + user + JSON-schema are
  * concatenated into one prompt delivered on stdin. `-p/--prompt` is deliberately
@@ -567,7 +597,11 @@ export function buildCopilotArgs(_opts: InferenceOptions): string[] {
     "--disable-builtin-mcps",
     "--no-auto-update",
     "--no-color",
-    "--allow-all-tools",
+    "--silent",
+    "--available-tools=none",
+    "--deny-tool=shell",
+    "--deny-tool=write",
+    "--deny-tool=url",
   ];
 }
 

package/src/hooks/lib/models.ts

@@ -9,7 +9,8 @@ export const HAIKU_5_5_MODEL = "claude-haiku-5-5";
 export const SONNET_MODEL = "claude-sonnet-5";
 export const FABLE_MODEL = "claude-fable-5";
 
-export type InferenceTier = "small" | "medium";
+export const INFERENCE_TIERS = ["small", "medium"] as const;
+export type InferenceTier = (typeof INFERENCE_TIERS)[number];
 
 export type FixedModelRoute =
   | "claude-spawn"

package/src/hooks/lib/paths.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
+import { homedir } from "node:os";
 import { isAbsolute, relative, resolve } from "node:path";
 
 /**
@@ -62,8 +62,12 @@ export function palPkg(): string {
  * Always resolves to ~/.pal/ regardless of where the package lives.
  * Power users who want memory/telos versioned in a repo can override via PAL_HOME.
  */
+function sandboxPalHome(): string {
+  return resolve(import.meta.dir, "..", "..", "..", ".test", "pal-home");
+}
+
 function defaultPalHome(): string {
-  if (process.env.PAL_TEST_SANDBOX) return resolve(tmpdir(), "pal-test-home");
+  if (process.env.PAL_TEST_SANDBOX) return sandboxPalHome();
   return resolve(homedir(), ".pal");
 }
 

package/src/hooks/lib/stop.ts

@@ -168,6 +168,7 @@ export async function runStopHandlers(
   // any in-hook budget. These spawn detached bun subprocesses that run the
   // inference and write results to disk; they don't block this hook.
   await detachSessionIntelligence(transcript, options.sessionId);
+  await detachEntityExtraction(transcript, options.sessionId);
   await detachFailurePrinciple(transcript);
   detachAgenda(options.sessionId);
   // Failure auto-graduation is intentionally NOT wired here: every pattern it
@@ -325,6 +326,24 @@ async function detachSessionIntelligence(
   }
 }
 
+async function detachEntityExtraction(
+  transcript: string,
+  sessionId?: string
+): Promise<void> {
+  if (!sessionId) return;
+  try {
+    const transcriptPath = await writeTranscriptTmp(transcript);
+    const scriptPath = resolve(assets.hooks(), "handlers", "entity-extraction.ts");
+    spawnDetachedInference(
+      scriptPath,
+      ["--run", sessionId, transcriptPath],
+      "entity-extraction"
+    );
+  } catch (err) {
+    logError("detachEntityExtraction", err);
+  }
+}
+
 /**
  * If a pending-failure exists, rename it to a unique path (race-free claim),
  * write the transcript to tmp, spawn the failure-principle handler detached.

package/src/hooks/lib/token-usage.ts

@@ -14,6 +14,7 @@ type TokenCaller =
   | "failure"
   | "session-name"
   | "session-intelligence"
+  | "entity-extraction"
   | "relationship"
   | "self-model"
   | "agenda-serves"

package/src/tools/knowledge/ingest.ts

@@ -29,7 +29,14 @@ import {
 
 // --- Public input shape -----------------------------------------------------
 
-export interface PersonInput {
+interface Addressing {
+  aliases?: string[] | null;
+  relation?: string | null;
+  /** The stored file to update, when its slug is not derived from the name or domain. */
+  slug?: string | null;
+}
+
+export interface PersonInput extends Addressing {
   name: string;
   role?: string | null;
   title?: string | null;
@@ -40,7 +47,7 @@ export interface PersonInput {
   [extra: string]: unknown;
 }
 
-export interface CompanyInput {
+export interface CompanyInput extends Addressing {
   name: string;
   domain?: string | null;
   industry?: string | null;
@@ -201,7 +208,17 @@ function newPersonEntity(input: PersonInput, slug: string): Entity {
   if (Object.keys(socials).length > 0) {
     fm.socials = Object.entries(socials).map(([k, v]) => `${k}:${v}`);
   }
-  return { domain: "People", slug, frontmatter: fm, body: "" };
+  return { domain: "People", slug, frontmatter: withAddressing(fm, input), body: "" };
+}
+
+/** How the user refers to an entity and stands towards it — both only ever grow. */
+function withAddressing(fm: EntityFrontmatter, input: Addressing): EntityFrontmatter {
+  const prior = Array.isArray(fm.aliases) ? (fm.aliases as string[]) : undefined;
+  const aliases = mergeStringArray(prior, input.aliases ?? undefined);
+  if (aliases.length > 0) fm.aliases = aliases;
+  const relation = mergeScalar(fm.relation, input.relation);
+  if (relation) fm.relation = relation;
+  return fm;
 }
 
 function newCompanyEntity(input: CompanyInput, slug: string): Entity {
@@ -220,7 +237,7 @@ function newCompanyEntity(input: CompanyInput, slug: string): Entity {
   if (input.industry) fm.industry = input.industry;
   if (input.mentioned_as) fm.mentioned_as = input.mentioned_as;
   if (input.sentiment) fm.sentiment = input.sentiment;
-  return { domain: "Companies", slug, frontmatter: fm, body: "" };
+  return { domain: "Companies", slug, frontmatter: withAddressing(fm, input), body: "" };
 }
 
 function mergePerson(prior: Entity, input: PersonInput): Entity {
@@ -248,7 +265,7 @@ function mergePerson(prior: Entity, input: PersonInput): Entity {
   if (Object.keys(socials).length > 0) {
     fm.socials = Object.entries(socials).map(([k, v]) => `${k}:${v}`);
   }
-  return { ...prior, frontmatter: fm };
+  return { ...prior, frontmatter: withAddressing(fm, input) };
 }
 
 function mergeCompany(prior: Entity, input: CompanyInput): Entity {
@@ -260,7 +277,7 @@ function mergeCompany(prior: Entity, input: CompanyInput): Entity {
   if (input.industry) {
     fm.tags = mergeStringArray(fm.tags, industryToTopicTags(input.industry));
   }
-  return { ...prior, frontmatter: fm };
+  return { ...prior, frontmatter: withAddressing(fm, input) };
 }
 
 function upsertPerson(
@@ -268,7 +285,7 @@ function upsertPerson(
   sourceId: string,
   rootDir?: string
 ): UpsertResult {
-  const slug = slugify(input.name);
+  const slug = input.slug || slugify(input.name);
   if (!slug) throw new Error(`ingest: cannot slugify person name "${input.name}"`);
   const prior = load("People", slug, rootDir);
   const created = prior === null;
@@ -294,7 +311,7 @@ function upsertCompany(
   rootDir?: string
 ): UpsertResult {
   const baseKey = input.domain?.trim() ? input.domain : input.name;
-  const slug = slugify(baseKey);
+  const slug = input.slug || slugify(baseKey);
   if (!slug) throw new Error(`ingest: cannot slugify company "${input.name}"`);
   const prior = load("Companies", slug, rootDir);
   const created = prior === null;