@pi-unipi/background-tasks 2.16.1 → 2.17.0

package/src/delegate-extension.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
+import { packageAssetSearchHint, resolvePackageAsset } from './package-assets.js';
 import type {
   ExtensionAPI,
   ExtensionContext,
@@ -10,14 +10,7 @@ import { Text } from '@earendil-works/pi-tui';
 import { Type, type Static } from 'typebox';
 import type { BgTask, BgTaskSnapshot, StartDelegateTaskOptions } from './types.js';
 import { truncateChars } from './types.js';
-import { sha256Buffer } from './attested-pi-run.js';
-import { readFusionCommittedResult, readFusionFailureResult } from './fusion/result-package.js';
-import {
-  cloneFusionUsage,
-  type FusionFailureResultView,
-  type FusionUsage,
-  type FusionWorkflowId,
-} from './fusion/types.js';
+import { sha256Buffer } from './json-utils.js';
 import {
   DELEGATE_AUTO_DELIVER_MODES,
   DELEGATE_CAPABILITIES,
@@ -65,9 +58,7 @@ import type { DelegateHookContractEvidence } from './delegate/hook-contract.js';
  * the shipped copy is byte-identical to the recorded one, so the runtime gate
  * and the gate that proved it can never drift apart.
  */
-const HOOK_EVIDENCE_PATH = fileURLToPath(
-  new URL('./delegate/hook-contract-evidence.json', import.meta.url),
-);
+const HOOK_EVIDENCE_RELATIVE_PATH = 'src/delegate/hook-contract-evidence.json';
 
 export const DelegateParams = Type.Object(
   {
@@ -135,7 +126,7 @@ export const DelegateParams = Type.Object(
 const ResultParams = Type.Object(
   {
     taskId: Type.String({
-      description: 'Background delegate or Fusion task id returned by its launch tool.',
+      description: 'Background delegate task id returned by bg_delegate.',
     }),
     delivery: Type.Optional(
       Type.String({
@@ -179,29 +170,7 @@ export interface DelegateLaunchDetails {
   trigger_on_completion: boolean;
 }
 
-export interface FusionBackgroundResultDetails {
-  schema_version: 'unipi-background-tasks.fusion-result-view.v1';
-  task_id: string;
-  state: 'running' | 'committed' | 'failed' | 'cancelled';
-  delivery: DelegateDeliveryMode | 'none';
-  workflow: FusionWorkflowId;
-  artifact_dir: string;
-  answer_bytes?: number | undefined;
-  answer_sha256?: string | undefined;
-  usage_delivered?: boolean | undefined;
-  answer?: { present: false; reason: 'run_did_not_commit' } | undefined;
-  summary_status?: FusionFailureResultView['summary_status'] | undefined;
-  failure_summary_ref?: FusionFailureResultView['failure_summary_ref'] | undefined;
-  failure?: FusionFailureResultView['failure'] | undefined;
-  progress?: FusionFailureResultView['progress'] | undefined;
-  usage_so_far?: FusionFailureResultView['usage_so_far'] | undefined;
-  attempts?: FusionFailureResultView['attempts'] | undefined;
-  evidence_artifacts?: FusionFailureResultView['evidence_artifacts'] | undefined;
-  remediation_ids?: FusionFailureResultView['remediation_ids'] | undefined;
-  summary_unavailable_reason?: FusionFailureResultView['summary_unavailable_reason'] | undefined;
-}
-
-export type BackgroundResultDetails = DelegateResultDetails | FusionBackgroundResultDetails;
+export type BackgroundResultDetails = DelegateResultDetails;
 
 export interface DelegateResultDetails {
   schema_version: 'unipi-background-tasks.delegate-result-view.v1';
@@ -306,18 +275,20 @@ export interface DelegateExtensionDependencies {
   startDelegateTask: (ctx: ExtensionContext, options: StartDelegateTaskOptions) => Promise<BgTask>;
   snapshot: (task: BgTask) => BgTaskSnapshot;
   resolveTask: (idOrPrefix: string) => BgTask;
-  claimFusionUsage: (task: BgTask) => Promise<boolean>;
   /** Overridable so tests can supply observed evidence without touching disk. */
   loadHookEvidence?: (() => Promise<DelegateHookContractEvidence>) | undefined;
 }
 
 async function defaultHookEvidence(): Promise<DelegateHookContractEvidence> {
   let raw: string;
+  const evidencePath =
+    resolvePackageAsset(HOOK_EVIDENCE_RELATIVE_PATH) ??
+    packageAssetSearchHint(HOOK_EVIDENCE_RELATIVE_PATH);
   try {
-    raw = await readFile(HOOK_EVIDENCE_PATH, 'utf8');
+    raw = await readFile(evidencePath, 'utf8');
   } catch (error) {
     throw new DelegateError(
-      `bg_delegate cannot verify the Pi hook contract: the recorded evidence at ${HOOK_EVIDENCE_PATH} is unreadable (${error instanceof Error ? error.message : String(error)}). No child was created.`,
+      `bg_delegate cannot verify the Pi hook contract: the recorded evidence at ${evidencePath} is unreadable (${error instanceof Error ? error.message : String(error)}). No child was created.`,
       {
         code: 'delegate_hook_contract_unsupported',
         childCreated: false,
@@ -517,10 +488,10 @@ export function registerDelegateExtension(
     name: DELEGATE_RESULT_TOOL_NAME,
     label: 'Background Result',
     description:
-      'Retrieve a hash-verified result from a bg_delegate or background Fusion task. Never blocks: a running task returns a typed not-ready result. Oversized answers are never truncated.',
-    promptSnippet: 'Retrieve the verified answer from a completed delegate or Fusion task',
+      'Retrieve a hash-verified result from a bg_delegate task. Never blocks: a running task returns a typed not-ready result. Oversized answers are never truncated.',
+    promptSnippet: 'Retrieve the verified answer from a completed delegate task',
     promptGuidelines: [
-      'Call bg_result once the delegate or Fusion terminal notification has arrived. It never blocks and must not be polled.',
+      'Call bg_result once the delegate terminal notification has arrived. It never blocks and must not be polled.',
       'A not-ready result means the task is still running; end the turn and wait for the notification.',
     ],
     parameters: ResultParams,
@@ -551,125 +522,10 @@ export function registerDelegateExtension(
           { code: 'task_unknown', childCreated: false },
         );
       }
-      const fusion = task.fusion;
-      if (fusion !== undefined) {
-        const requestedDelivery = requireDelivery(params.delivery);
-        if (task.status === 'running') {
-          const details: FusionBackgroundResultDetails = {
-            schema_version: 'unipi-background-tasks.fusion-result-view.v1',
-            task_id: task.id,
-            state: 'running',
-            delivery: 'none',
-            workflow: fusion.workflow,
-            artifact_dir: fusion.artifactDir,
-          };
-          return {
-            content: textContent(
-              `Fusion ${task.id} is still running. bg_result never blocks. End this turn; the terminal notification will wake you, then call bg_result again.`,
-            ),
-            details,
-          };
-        }
-        if (task.status !== 'completed' || fusion.outcome?.status !== 'committed') {
-          const terminal = await readFusionFailureResult({
-            artifactDirAbs: fusion.artifactDirAbs,
-            artifactDir: fusion.artifactDir,
-            runId: fusion.runId,
-            workflow: fusion.workflow,
-          });
-          const state =
-            fusion.outcome?.status === 'cancelled' || task.status === 'killed'
-              ? 'cancelled'
-              : 'failed';
-          const details: FusionBackgroundResultDetails = {
-            schema_version: 'unipi-background-tasks.fusion-result-view.v1',
-            task_id: task.id,
-            state,
-            delivery: 'none',
-            workflow: fusion.workflow,
-            artifact_dir: fusion.artifactDir,
-            answer: terminal.answer,
-            summary_status: terminal.summary_status,
-            ...(terminal.failure_summary_ref === undefined
-              ? {}
-              : { failure_summary_ref: terminal.failure_summary_ref }),
-            ...(terminal.failure === undefined ? {} : { failure: terminal.failure }),
-            ...(terminal.progress === undefined ? {} : { progress: terminal.progress }),
-            ...(terminal.usage_so_far === undefined ? {} : { usage_so_far: terminal.usage_so_far }),
-            ...(terminal.attempts === undefined ? {} : { attempts: terminal.attempts }),
-            ...(terminal.evidence_artifacts === undefined
-              ? {}
-              : { evidence_artifacts: terminal.evidence_artifacts }),
-            ...(terminal.remediation_ids === undefined
-              ? {}
-              : { remediation_ids: terminal.remediation_ids }),
-            ...(terminal.summary_unavailable_reason === undefined
-              ? {}
-              : { summary_unavailable_reason: terminal.summary_unavailable_reason }),
-          };
-          return {
-            content: textContent(
-              `Fusion ${task.id} ${state}; no answer was committed. Terminal evidence status: ${terminal.summary_status}. Delivery is none; use only the manifest-bound artifact references in details.`,
-            ),
-            details,
-          };
-        }
-        const verified = await readFusionCommittedResult({
-          artifactDirAbs: fusion.artifactDirAbs,
-          artifactDir: fusion.artifactDir,
-          runId: fusion.runId,
-          workflow: fusion.workflow,
-        });
-        const answerBytes = Buffer.byteLength(verified.mergedText, 'utf8');
-        const answerSha256 = sha256Buffer(Buffer.from(verified.mergedText, 'utf8'));
-        const useArtifact =
-          requestedDelivery === 'artifact' ||
-          (requestedDelivery === undefined && answerBytes > DELEGATE_INLINE_ANSWER_BYTES);
-        if (requestedDelivery === 'inline' && answerBytes > DELEGATE_INLINE_ANSWER_BYTES) {
-          throw new Error(
-            `Fusion result ${task.id} is ${String(answerBytes)} bytes, above the ${String(DELEGATE_INLINE_ANSWER_BYTES)}-byte inline limit. Use delivery:"artifact"; nothing was truncated.`,
-          );
-        }
-        const usageDelivered = await deps.claimFusionUsage(task);
-        const details: FusionBackgroundResultDetails = {
-          schema_version: 'unipi-background-tasks.fusion-result-view.v1',
-          task_id: task.id,
-          state: 'committed',
-          delivery: useArtifact ? 'artifact' : 'inline',
-          workflow: fusion.workflow,
-          artifact_dir: fusion.artifactDir,
-          answer_bytes: answerBytes,
-          answer_sha256: answerSha256,
-          usage_delivered: usageDelivered,
-        };
-        const header = [
-          `Fusion ${task.id} completed (${fusion.workflow}).`,
-          `Answer: ${String(answerBytes)} bytes, ${answerSha256} (verified).`,
-          `Artifacts: ${fusion.artifactDir}`,
-          usageDelivered
-            ? 'Usage: attached to this retrieval exactly once.'
-            : 'Usage: already attached by an earlier retrieval; not counted again.',
-        ].join('\n');
-        const result = useArtifact
-          ? {
-              content: textContent(
-                `${header}\nDelivery: artifact. The complete answer is ${fusion.artifactDir}/merged.md; it was not truncated.`,
-              ),
-              details,
-            }
-          : { content: textContent(`${header}\n\n${verified.mergedText}`), details };
-        if (!usageDelivered) return result;
-        const resultWithUsage: typeof result & { usage: FusionUsage } = {
-          ...result,
-          usage: cloneFusionUsage(verified.details.usage),
-        };
-        return resultWithUsage;
-      }
-
       const facts = task.delegate;
       if (facts === undefined) {
         throw new DelegateError(
-          `bg_result task ${task.id} has no retrievable delegate or Fusion result; use bg_logs for ordinary background tasks`,
+          `bg_result task ${task.id} has no retrievable delegate result; use bg_logs for ordinary background tasks`,
           { code: 'task_unknown', childCreated: false },
         );
       }
@@ -772,22 +628,14 @@ export function registerDelegateExtension(
     renderResult(result, options: ToolRenderResultOptions, theme: Theme) {
       void options;
       const details = result.details;
-      const fusion = details.schema_version === 'unipi-background-tasks.fusion-result-view.v1';
       if (details.state === 'running')
         return new Text(
-          theme.fg('warning', `${fusion ? 'fusion' : 'delegate'} ${details.task_id} still running`),
+          theme.fg('warning', `delegate ${details.task_id} still running`),
           0,
           0,
         );
-      if (fusion && (details.state === 'failed' || details.state === 'cancelled')) {
-        return new Text(
-          theme.fg('warning', `${details.state} fusion; no committed answer · ${details.summary_status ?? 'unavailable'}`),
-          0,
-          0,
-        );
-      }
       return new Text(
-        `${theme.fg('success', fusion ? '✓ fusion answer' : '✓ delegate answer')} ${theme.fg('dim', `${String(details.answer_bytes ?? 0)}B · ${details.delivery}`)}`,
+        `${theme.fg('success', '✓ delegate answer')} ${theme.fg('dim', `${String(details.answer_bytes ?? 0)}B · ${details.delivery}`)}`,
         0,
         0,
       );

package/src/index.ts

@@ -10,6 +10,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createSpinnerLine } from "@pi-unipi/core";
 import { loadBackgroundTasksConfig } from "./config.js";
 import { BackgroundTaskRegistry } from "./registry.js";
 import {
@@ -17,16 +18,32 @@ import {
   type BackgroundTaskExtensionService,
 } from "./extension-api.js";
 import { registerToolsAndCommands } from "./tools.js";
-import { registerFusionExtension } from "./fusion-extension.js";
 import { registerDelegateExtension } from "./delegate-extension.js";
 import { setSharedTaskRegistry, clearSharedTaskRegistry } from "./registry-shared.js";
-import { taskDisplayName, type BgTask, type StartAttestedPiTaskOptions, type StartTaskOptions } from "./types.js";
+import { formatDuration, taskDisplayName, type BgTask, type StartTaskOptions } from "./types.js";
 
 const STATUS_INTERVAL_MS = 1000;
 
 // Direct synchronous access for sibling extensions (footer process one-liner).
 export { getSharedTaskRegistry } from "./registry-shared.js";
 
+/** Live line above the editor: the agent is idle but a task will wake it. */
+function pendingWakeText(registry: BackgroundTaskRegistry, isIdle: () => boolean): string | undefined {
+  if (!isIdle()) return undefined;
+  const pendingWake = registry
+    .allTasks()
+    .filter((task) => task.status === "running" && task.triggerOnCompletion);
+  if (pendingWake.length === 0) return undefined;
+  const now = Date.now();
+  const first = pendingWake[0];
+  const detail =
+    first === undefined
+      ? ""
+      : ` · ${taskDisplayName(first)} ${formatDuration(now - first.startTime)}${pendingWake.length > 1 ? ` +${String(pendingWake.length - 1)} more` : ""}`;
+  const count = pendingWake.length === 1 ? "1 bg task" : `${String(pendingWake.length)} bg tasks`;
+  return `waiting on ${count}${detail} — agent resumes automatically when done`;
+}
+
 export default function backgroundTasksExtension(pi: ExtensionAPI): void {
   const { config, warnings } = loadBackgroundTasksConfig(process.cwd());
 
@@ -41,6 +58,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
   const seenTaskIds = new Set<string>();
   let currentCtx: ExtensionContext | undefined;
   let dockOpen = false;
+  let wakeLineInstalled = false;
   let statusInterval: NodeJS.Timeout | undefined;
 
   const registry = new BackgroundTaskRegistry({
@@ -92,7 +110,34 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
       const unseenDone = allTasks.filter((task) => task.status === "completed" && !seenTaskIds.has(task.id));
       const unseenFinishedCount = unseenFailed.length + unseenStopped.length + unseenDone.length;
 
-      target.ui.setWidget("background-tasks", undefined);
+      // Pending-wake indicator. When the agent is idle but a bg task that will
+      // wake it is still running, the UI otherwise looks finished and users
+      // assume the turn is over. Install a self-animating spinner line above
+      // the editor ONCE while any such task exists (the widget owns its 80 ms
+      // frame timer and re-reads the registry on every frame, so this 1 s
+      // poll only decides whether the widget exists — never its animation).
+      const isIdle = () => {
+        try {
+          return target.isIdle();
+        } catch {
+          return true;
+        }
+      };
+      const wantWakeLine = pendingWakeText(registry, isIdle) !== undefined;
+      if (wantWakeLine && !wakeLineInstalled) {
+        target.ui.setWidget(
+          "background-tasks",
+          createSpinnerLine({
+            text: () => pendingWakeText(registry, isIdle),
+            colorSpinner: (g: string) => `\x1b[38;5;82m${g}\x1b[0m`,
+          }),
+          { placement: "aboveEditor" },
+        );
+        wakeLineInstalled = true;
+      } else if (!wantWakeLine && wakeLineInstalled) {
+        target.ui.setWidget("background-tasks", undefined);
+        wakeLineInstalled = false;
+      }
       if (running.length === 0 && unseenFinishedCount === 0) {
         target.ui.setStatus("background-tasks", undefined);
         return;
@@ -103,7 +148,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
       if (unseenFailed.length > 0) parts.push(`${String(unseenFailed.length)} failed`);
       if (unseenStopped.length > 0) parts.push(`${String(unseenStopped.length)} stopped`);
       if (unseenDone.length > 0) parts.push(`${String(unseenDone.length)} done`);
-      const entryHint = dockOpen ? "focused" : `Shift↓${unseenFinishedCount > 0 ? " · /unipi:bg-clear" : ""}`;
+      const entryHint = dockOpen ? "focused" : `Shift↓${unseenFinishedCount > 0 ? " · Ctrl+Alt+C clear" : ""}`;
       const label = ` bg ${[...parts, entryHint].join(" · ")} `;
       target.ui.setStatus("background-tasks", label);
     } catch (error) {
@@ -119,19 +164,11 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
     return registry.startTask(ctx, command, opts);
   }
 
-  async function startAttestedPiTask(
-    ctx: ExtensionContext,
-    opts: StartAttestedPiTaskOptions,
-  ): Promise<BgTask> {
-    currentCtx = ctx;
-    return registry.startAttestedPiTask(ctx, opts);
-  }
-
   async function openTaskManager(ctx: ExtensionContext, initialTaskId?: string): Promise<void> {
     currentCtx = ctx;
     if (!ctx.hasUI) {
       ctx.ui.notify(
-        "Background task manager requires an interactive UI. Use /unipi:jobs, /unipi:logs, or the bg_status/bg_logs tools in non-interactive mode.",
+        "Background task manager requires an interactive UI. Use the bg_status/bg_logs tools in non-interactive mode.",
         "error",
       );
       return;
@@ -156,7 +193,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
               return result;
             },
             rerunTask: async (task) => {
-              if (task.fusion !== undefined || task.delegate !== undefined) {
+              if (task.delegate !== undefined) {
                 throw new Error(
                   "Only shell-command tasks can be rerun from the dock; relaunch this typed workflow through its owning tool.",
                 );
@@ -232,21 +269,11 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
     pi,
     registry,
     startTask,
-    startAttestedPiTask,
     openTaskManager,
     clearFinishedNotices,
     openSettings,
   });
 
-  registerFusionExtension(pi, {
-    startManagedTask: async (ctx, options) => {
-      currentCtx = ctx;
-      return registry.startManagedTask(ctx, options);
-    },
-    snapshot: (task) => registry.snapshot(task),
-    updateManagedTask: (task, state, line) => registry.updateManagedTask(task, state, line),
-  });
-
   registerDelegateExtension(pi, {
     startDelegateTask: async (ctx, options) => {
       currentCtx = ctx;
@@ -254,11 +281,11 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
     },
     snapshot: (task) => registry.snapshot(task),
     resolveTask: (idOrPrefix) => registry.resolveTask(idOrPrefix),
-    claimFusionUsage: (task) => registry.claimFusionUsage(task),
   });
 
   pi.on("session_start", async (_event, ctx) => {
     registry.setShuttingDown(false);
+    wakeLineInstalled = false; // pi clears extension widgets on reload/new session
     setSharedTaskRegistry(registry);
     currentCtx = ctx;
     await registry.ensureRuntimeDir(ctx);
@@ -271,6 +298,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
 
   pi.on("session_shutdown", async (_event, ctx) => {
     registry.setShuttingDown(true);
+    wakeLineInstalled = false;
     clearSharedTaskRegistry();
     currentCtx = undefined;
     if (statusInterval) {

package/src/json-utils.ts

@@ -0,0 +1,56 @@
+/**
+ * @pi-unipi/background-tasks — small hashing / canonical-JSON helpers shared by
+ * the delegate artifact store and registry metadata writes.
+ */
+import { createHash } from 'node:crypto';
+import { isJsonObject } from './types.js';
+import { replaceFileDurable } from './durable-fs.js';
+
+export function sha256Buffer(buffer: Buffer): string {
+  return `sha256:${createHash('sha256').update(buffer).digest('hex')}`;
+}
+
+export function canonicalJson(value: unknown): string {
+  return JSON.stringify(sortJson(value));
+}
+
+function sortJson(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (!isJsonObject(value)) return value;
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort()
+      .map((key) => [key, sortJson(value[key])]),
+  );
+}
+
+export async function writeJsonAtomic(path: string, value: unknown): Promise<void> {
+  await replaceFileDurable(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function closeAndFsyncOutputStream(
+  stream: NodeJS.WritableStream | undefined,
+): Promise<void> {
+  if (!stream) return;
+  await new Promise<void>((resolvePromise, reject) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      stream.off('error', fail);
+      stream.off('close', finish);
+      stream.off('finish', finish);
+      resolvePromise();
+    };
+    const fail = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      stream.off('close', finish);
+      reject(error);
+    };
+    stream.once('close', finish);
+    stream.once('finish', finish);
+    stream.once('error', fail);
+    stream.end();
+  });
+}

package/src/package-assets.ts

@@ -0,0 +1,51 @@
+/**
+ * @pi-unipi/background-tasks — locate package-owned assets from any entry.
+ *
+ * The delegate child guard (`extensions/delegate-child.ts`) and the recorded
+ * hook-contract evidence (`src/delegate/hook-contract-evidence.json`) must be
+ * found both when this package runs from source (`src/…`) and when it runs from
+ * the umbrella bundle (`packages/unipi/bundled.js`, where `import.meta.url` no
+ * longer points inside this package). We therefore walk upward from the calling
+ * module until we find a `packages/background-tasks/` (or the package root
+ * itself) that contains the asset.
+ */
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export interface ResolvePackageAssetOptions {
+  moduleUrl?: string | undefined;
+  pathExists?: ((path: string) => boolean) | undefined;
+}
+
+const PACKAGE_DIR_NAME = 'background-tasks';
+
+/**
+ * Resolve `relativePath` (relative to this package's root, e.g.
+ * `extensions/delegate-child.ts`) or return undefined when no candidate exists.
+ */
+export function resolvePackageAsset(
+  relativePath: string,
+  options: ResolvePackageAssetOptions = {},
+): string | undefined {
+  const pathExists = options.pathExists ?? existsSync;
+  const modulePath = fileURLToPath(options.moduleUrl ?? import.meta.url);
+  let dir = dirname(modulePath);
+  for (let depth = 0; depth < 8; depth++) {
+    const candidates = [
+      resolve(dir, relativePath),
+      resolve(dir, PACKAGE_DIR_NAME, relativePath),
+      resolve(dir, 'packages', PACKAGE_DIR_NAME, relativePath),
+      resolve(dir, 'node_modules', '@pi-unipi', PACKAGE_DIR_NAME, relativePath),
+    ];
+    for (const candidate of candidates) if (pathExists(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
+export function packageAssetSearchHint(relativePath: string): string {
+  return join('packages', PACKAGE_DIR_NAME, relativePath);
+}