@timurproko/a1 0.2.6-dev.717 → 0.2.6-dev.734

package/bin/cli.js

@@ -55,8 +55,19 @@ process.exitCode = await dispatchCli(process.argv.slice(2), {
     return await runPackageCommand(request, { createPort: createPiPackagesPort });
   },
   sessionContext: async request => {
-    const { runSessionContextCommand } = await import("../dist/cli/session-context.js");
-    return await runSessionContextCommand(request);
+    const [{ runSessionContextCommand }, { createNativeProcessInspector }, { readLaunchContext }] = await Promise.all([
+      import("../dist/cli/session-context.js"),
+      import("../dist/foundation/process-containment/native-process-inspector.js"),
+      import("../dist/foundation/launch-context/index.js"),
+    ]);
+    const launch = readLaunchContext(process.env);
+    let inspector;
+    return await runSessionContextCommand(request, {
+      inspectProcess: async pid => {
+        inspector ??= createNativeProcessInspector(process.env, process.platform, launch.releaseRoot);
+        return (await inspector).observe(pid);
+      },
+    });
   },
 }, {
   stdout: message => process.stdout.write(message),

package/bin/ui.js

@@ -9,6 +9,13 @@ const { readLaunchContext } = await import("../dist/foundation/launch-context/in
 const launchContext = readLaunchContext(process.env, "profile");
 const profile = launchContext.launchProfile;
 if (profile === undefined) throw new Error("A1 launch profile is missing");
+if (profile === "a1") {
+  const [{ randomUUID }, { PRODUCT_IDENTITY }] = await Promise.all([
+    import("node:crypto"),
+    import("../dist/product-identity.js"),
+  ]);
+  process.env[PRODUCT_IDENTITY.environment.sessionRuntimeId] = randomUUID();
+}
 const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/fatal-exit.js");
 const { resolveProductPaths } = await import("../dist/foundation/lifecycle/paths.js");
 const { join } = await import("node:path");
@@ -49,10 +56,16 @@ Promise.resolve().then(() => {
   if (sessionSelection && profile !== "a1") throw new Error("session selection requires the normal A1 profile");
   return runSelectedInteractiveRuntime(profile, {
     ownedUi: async (profileId, ownedSurfaces) => {
+      const processInspector = ownedSurfaces
+        ? await import("../dist/foundation/process-containment/native-process-inspector.js")
+          .then(module => module.createNativeProcessInspector(process.env, process.platform, launchContext.releaseRoot))
+          .catch(() => null)
+        : null;
       const { application, settings } = await composeOwnedUi({
         cwd: process.cwd(),
         profileId,
         ownedSurfaces,
+        ...(processInspector === null ? {} : { inspectProcess: pid => processInspector.observe(pid) }),
         projectTrustPrompt: createConsoleProjectTrustPrompt({ presentation: profile === "a1" ? "bare" : "comparison" }),
         sessionForkPrompt: createConsoleSessionForkPrompt(),
         ...(sessionSelection === undefined ? {} : { sessionSelection }),

package/dist/app/session-shell/clipboard-services.d.ts

@@ -0,0 +1,19 @@
+import type { HelperPool } from "./helper-pool.js";
+/**
+ * Process-wide clipboard helper spares. Composition creates one and every session shell borrows it, so N
+ * sessions keep at most one spare paste helper and one spare copy helper instead of 2N. Shells warm the
+ * pools after their first frame; only the creator disposes them.
+ */
+export interface OwnedUiClipboardServices {
+    readonly paste: HelperPool;
+    readonly copy: HelperPool;
+    dispose(): void;
+}
+export interface OwnedUiClipboardServicesOptions {
+    /** Package/fault-test seams for the forked helpers' entries. */
+    readonly pasteHelper?: URL;
+    readonly copyHelper?: URL;
+    /** Idle bound for both spares; production keeps the default. */
+    readonly spareIdleMs?: number;
+}
+export declare function createOwnedUiClipboardServices(options?: OwnedUiClipboardServicesOptions): OwnedUiClipboardServices;

package/dist/app/session-shell/clipboard-services.js

@@ -0,0 +1,7 @@
+import { createPasteHelperPool } from "./paste-executor.js";
+import { createCopyHelperPool } from "./response-copy-transport.js";
+export function createOwnedUiClipboardServices(options = {}) {
+    const paste = createPasteHelperPool(options.pasteHelper, options.spareIdleMs);
+    const copy = createCopyHelperPool(options.copyHelper, options.spareIdleMs);
+    return { paste, copy, dispose: () => { paste.dispose(); copy.dispose(); } };
+}

package/dist/app/session-shell/exit-notice.d.ts

@@ -1,10 +1,14 @@
 import { type SessionResumeCommandMetadata } from "./session-shell.js";
 export interface ExitNoticeSource {
-    readonly sessionGeneration: number;
-    currentSessionResumeMetadata(): SessionResumeCommandMetadata | null;
-    onEvent(listener: (event: {
-        readonly type: string;
-    }) => void): () => void;
+    readonly identity: {
+        readonly sessionGeneration: number;
+        currentSessionResumeMetadata(): SessionResumeCommandMetadata | null;
+    };
+    readonly session: {
+        onEvent(listener: (event: {
+            readonly type: string;
+        }) => void): () => void;
+    };
 }
 export interface ArmedExitNotice {
     clear(): void;

package/dist/app/session-shell/exit-notice.js

@@ -17,12 +17,12 @@ export function uncleanExitNoticeLines(resume) {
 export function armExitNotice(source, path) {
     let current = null;
     let cleared = false;
-    let generation = source.sessionGeneration;
+    let generation = source.identity.sessionGeneration;
     const write = () => {
         if (cleared)
             return;
         // Protocol: plain text only; the guardian strips control characters, so styling would be lost.
-        const text = `${uncleanExitNoticeLines(source.currentSessionResumeMetadata()).join("\n")}\n`;
+        const text = `${uncleanExitNoticeLines(source.identity.currentSessionResumeMetadata()).join("\n")}\n`;
         if (text === current)
             return;
         try {
@@ -35,13 +35,13 @@ export function armExitNotice(source, path) {
         catch { }
     };
     write();
-    const unsubscribe = source.onEvent(event => {
+    const unsubscribe = source.session.onEvent(event => {
         // Rationale: a session is persisted by its first response and replaced by /new or /resume;
         // these events cover both without touching the per-chunk stream.
-        const replaced = source.sessionGeneration !== generation;
+        const replaced = source.identity.sessionGeneration !== generation;
         if (!replaced && event.type !== "session-lifecycle" && event.type !== "assistant-message-completed")
             return;
-        generation = source.sessionGeneration;
+        generation = source.identity.sessionGeneration;
         write();
     });
     return {

package/dist/app/session-shell/index.d.ts

@@ -1,7 +1,9 @@
 export { ClipboardDiagnosticCapture } from "./clipboard-diagnostics.js";
+export { createOwnedUiClipboardServices } from "./clipboard-services.js";
+export type { OwnedUiClipboardServices, OwnedUiClipboardServicesOptions } from "./clipboard-services.js";
 export { ContextualPromptSuggestionController, samePromptSuggestionIdentity } from "./prompt-suggestion-controller.js";
 export type { ContextualPromptSuggestionControllerOptions, ContextualPromptSuggestionSurface } from "./prompt-suggestion-controller.js";
 export { OwnedUiSessionShell, OwnedUiSessionShellRoot, formatSessionResumeCommand, quoteCommandArgument } from "./session-shell.js";
-export type { OwnedUiSessionShellOptions, OwnedUiShellDiagnosticOptions, OwnedUiShellEngineOptions, OwnedUiShellHistoryOptions, OwnedUiShellPresentationOptions, OwnedUiShellPromptImagesOptions, OwnedUiShellSkillsOptions, OwnedUiShellSuggestionOptions, SessionResumeCommandMetadata, } from "./session-shell.js";
+export type { OwnedUiSessionShellOptions, OwnedUiShellDiagnosticOptions, OwnedUiShellEngineOptions, OwnedUiShellHistoryOptions, OwnedUiShellPresentationOptions, OwnedUiShellPromptImagesOptions, OwnedUiShellSharedServices, OwnedUiShellSkillsOptions, OwnedUiShellSuggestionOptions, SessionResumeCommandMetadata, } from "./session-shell.js";
 export { STREAM_PRESENTATION_INTERVAL_MS, StreamPresentationCoalescer } from "./stream-presentation-coalescer.js";
 export type { StreamPresentationScheduler } from "./stream-presentation-coalescer.js";

package/dist/app/session-shell/index.js

@@ -1,4 +1,5 @@
 export { ClipboardDiagnosticCapture } from "./clipboard-diagnostics.js";
+export { createOwnedUiClipboardServices } from "./clipboard-services.js";
 export { ContextualPromptSuggestionController, samePromptSuggestionIdentity } from "./prompt-suggestion-controller.js";
 export { OwnedUiSessionShell, OwnedUiSessionShellRoot, formatSessionResumeCommand, quoteCommandArgument } from "./session-shell.js";
 export { STREAM_PRESENTATION_INTERVAL_MS, StreamPresentationCoalescer } from "./stream-presentation-coalescer.js";

package/dist/app/session-shell/paste-preparation-client.d.ts

@@ -1,4 +1,5 @@
 import { startPasteExecutor } from "./paste-executor.js";
+import type { HelperPool } from "./helper-pool.js";
 import { type PasteEvent, type PasteSource, type PreparedPaste } from "./paste-protocol.js";
 export interface PreparedPasteJob<T> {
     readonly result: Promise<T>;
@@ -16,6 +17,8 @@ export interface PastePreparationClientOptions {
     readonly helper?: URL;
     /** Idle bound for the spare helper; production keeps the default. */
     readonly spareIdleMs?: number;
+    /** Process-wide spare pool shared across sessions; the client warms it but never disposes it. */
+    readonly pool?: HelperPool;
 }
 /** Keeps eight distinct paste transactions alive through insertion; canceled executors retain capacity until fenced. */
 export declare class PastePreparationClient {

package/dist/app/session-shell/paste-preparation-client.js

@@ -8,13 +8,15 @@ export class PastePreparationClient {
     #execute;
     #helper;
     #pool;
+    #ownsPool;
     #sequence = 0;
     #disposed = false;
     constructor(options = {}) {
         this.#onEvent = options.onEvent;
         this.#execute = options.execute ?? startPasteExecutor;
         this.#helper = options.helper;
-        this.#pool = options.execute === undefined ? createPasteHelperPool(options.helper, options.spareIdleMs) : undefined;
+        this.#pool = options.execute === undefined ? options.pool ?? createPasteHelperPool(options.helper, options.spareIdleMs) : undefined;
+        this.#ownsPool = options.pool === undefined;
     }
     /** Forks the spare helper now so the first paste takes a live child; later pastes rewarm it themselves. */
     warm() { this.#pool?.warm(); }
@@ -160,7 +162,8 @@ export class PastePreparationClient {
     async dispose() {
         this.#disposed = true;
         this.reset();
-        this.#pool?.dispose();
+        if (this.#ownsPool)
+            this.#pool?.dispose();
         let timer;
         await Promise.race([Promise.all([...this.#active].map(active => active.stopped)),
             new Promise(resolve => { timer = setTimeout(resolve, PASTE_STOP_MS); timer.unref(); })]);

package/dist/app/session-shell/path-chip-presentation.d.ts

@@ -1,7 +1,14 @@
 import type { ClipboardPath, PreparedPasteText } from "./paste-types.js";
 export declare const PATH_CHIP_PRESENTATION_UNITS = 4096;
-export declare const PATH_CHIP_SUFFIX_UNITS = 20;
-/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
-export declare function pathChipTag(item: ClipboardPath): string;
+/** Normalizes a path for host-filesystem identity comparisons. */
+export declare function normalizedPathIdentity(fullPath: string): string;
+/** Yields labels from the basename through the normalized rooted path, shortest first. */
+export declare function pathChipLabelCandidates(fullPath: string): Iterable<string>;
+/** Formats one path label with the established folder/file/image-file icon. */
+export declare function pathChipTag(item: ClipboardPath, label?: string): string;
+/** Yields complete deterministic tags lazily for path collision adoption. */
+export declare function pathChipTagCandidates(item: ClipboardPath): Iterable<string>;
+/** Returns the conservative UTF-16 presentation cost for one path occurrence. */
+export declare function pathChipPresentationUnits(item: ClipboardPath): number;
 /** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
 export declare function preparePathPresentation(paths: readonly ClipboardPath[]): PreparedPasteText;

package/dist/app/session-shell/path-chip-presentation.js

@@ -1,19 +1,52 @@
 import path from "node:path";
 export const PATH_CHIP_PRESENTATION_UNITS = 4096;
-// Invariant: a collision suffix containing any safe-integer index fits this per-occurrence reserve.
-export const PATH_CHIP_SUFFIX_UNITS = 20;
 const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
-/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
-export function pathChipTag(item) {
-    const label = path.basename(item.fullPath) || path.parse(item.fullPath).root.replace(/[\\/]+$/u, "") || item.fullPath;
+/** Normalizes a path for host-filesystem identity comparisons. */
+export function normalizedPathIdentity(fullPath) {
+    const normalized = path.normalize(fullPath.trim());
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+/** Yields labels from the basename through the normalized rooted path, shortest first. */
+export function* pathChipLabelCandidates(fullPath) {
+    const normalized = path.normalize(fullPath.trim());
+    const parsed = path.parse(normalized);
+    const relative = normalized.slice(parsed.root.length);
+    const segments = relative.split(path.sep).filter(segment => segment.length > 0);
+    let previous = "";
+    for (let depth = 1; depth <= segments.length; depth++) {
+        previous = segments.slice(-depth).join("/");
+        yield previous;
+    }
+    const rooted = displayPath(normalized);
+    if (segments.length === 0) {
+        const root = displayPath(parsed.root).replace(/\/$/u, "");
+        if (root.length > 0) {
+            previous = root;
+            yield root;
+        }
+    }
+    if (rooted.length > 0 && rooted !== previous)
+        yield rooted;
+}
+/** Formats one path label with the established folder/file/image-file icon. */
+export function pathChipTag(item, label = basePathLabel(item.fullPath)) {
     const icon = item.kind === "folder" ? "📁" : IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
     return `[${icon} ${label}]`;
 }
+/** Yields complete deterministic tags lazily for path collision adoption. */
+export function* pathChipTagCandidates(item) {
+    for (const label of pathChipLabelCandidates(item.fullPath))
+        yield pathChipTag(item, label);
+}
+/** Returns the conservative UTF-16 presentation cost for one path occurrence. */
+export function pathChipPresentationUnits(item) {
+    return pathChipTag(item, displayPath(path.normalize(item.fullPath.trim()))).length;
+}
 /** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
 export function preparePathPresentation(paths) {
     let units = 0;
     for (const item of paths) {
-        units += pathChipTag(item).length + PATH_CHIP_SUFFIX_UNITS;
+        units += pathChipPresentationUnits(item);
         if (units > PATH_CHIP_PRESENTATION_UNITS) {
             // Compatibility: individual adjacent chips expand without inserted separators or text re-normalization.
             const text = paths.map(value => value.fullPath).join("");
@@ -22,3 +55,12 @@ export function preparePathPresentation(paths) {
     }
     return { kind: "paths", paths };
 }
+function basePathLabel(fullPath) {
+    const normalized = path.normalize(fullPath.trim());
+    return path.basename(normalized)
+        || displayPath(path.parse(normalized).root).replace(/\/$/u, "")
+        || displayPath(normalized);
+}
+function displayPath(value) {
+    return path.sep === "\\" ? value.replaceAll("\\", "/") : value;
+}

package/dist/app/session-shell/prompt-chips.js

@@ -1,10 +1,9 @@
 import { randomBytes } from "node:crypto";
-import path from "node:path";
 import { canonicalizeClipboardImage } from "./clipboard-image.js";
 import { assertImageEncodedSize, assertPromptImages, canonicalPromptChipMatches, DEFAULT_PROMPT_IMAGE_LIMIT, ImageAttachmentError, replaceCanonicalPromptChips, } from "../../contracts/owned-ui/index.js";
 import { ImagePreparationClient } from "./image-preparation-client.js";
 import { preparePasteText } from "./paste-text-preparation.js";
-import { pathChipTag } from "./path-chip-presentation.js";
+import { normalizedPathIdentity, pathChipTagCandidates } from "./path-chip-presentation.js";
 import { PastePreparationClient } from "./paste-preparation-client.js";
 const URL_SUBSTRING_PATTERN = /https?:\/\/[^\s\u0000-\u001f\u007f\]]+/giu;
 const IMAGE_CHIP_IDENTIFIER_PATTERN = /^\[📷 screenshot-([a-f0-9]+)(?:-resized)?\]$/u;
@@ -23,6 +22,7 @@ function referencesPasteMarker(text, entry) {
 /** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
 export class PromptChipStore {
     #chips = new Map();
+    #pathTags = new Map();
     // Invariant: clearing the editor never recycles a recoverable text chip's identity.
     #textCounter = 0;
     #pending = new Map();
@@ -199,6 +199,7 @@ export class PromptChipStore {
     async dispose() {
         await Promise.all([this.#preparation.dispose(), this.#isolated?.dispose(), ...this.#stopping]);
         this.#chips.clear();
+        this.#pathTags.clear();
         this.#pending.clear();
         this.#countRejectedImages.clear();
         this.#provisionalOwners.clear();
@@ -269,7 +270,26 @@ export class PromptChipStore {
             this.#claimChip(tag, owner, true);
             return tag;
         }
-        return paste.paths.map(item => this.#recordUnique({ kind: item.kind, tag: pathChipTag(item), path: item.fullPath }, owner)).join("");
+        return paste.paths.map(item => this.#recordPath(item, owner)).join("");
+    }
+    #recordPath(item, owner) {
+        const key = pathChipKey(item);
+        const establishedTag = this.#pathTags.get(key);
+        if (establishedTag !== undefined && this.#chips.has(establishedTag)) {
+            this.#claimChip(establishedTag, owner, false);
+            return establishedTag;
+        }
+        for (const tag of pathChipTagCandidates(item)) {
+            const chip = { kind: item.kind, tag, path: item.fullPath };
+            const existing = this.#chips.get(tag);
+            if (existing !== undefined && !sameChipValue(existing, chip))
+                continue;
+            this.#chips.set(tag, chip);
+            this.#pathTags.set(key, tag);
+            this.#claimChip(tag, owner, existing === undefined);
+            return tag;
+        }
+        throw new Error("Path chip labels could not distinguish normalized paths");
     }
     /** Hide provisional clipboard identities until the read identifies an actual image. */
     hiddenRanges(line) {
@@ -501,7 +521,10 @@ export class PromptChipStore {
                 owners.delete(owner);
                 if (owners.size === 0) {
                     this.#provisionalOwners.delete(tag);
+                    const chip = this.#chips.get(tag);
                     this.#chips.delete(tag);
+                    if (chip?.kind === "file" || chip?.kind === "folder")
+                        this.#pathTags.delete(pathChipKey(chip));
                 }
             }
         }
@@ -522,13 +545,16 @@ export class PromptChipStore {
         return uniqueTag;
     }
 }
+function pathChipKey(item) {
+    return `${item.kind}\0${normalizedPathIdentity("fullPath" in item ? item.fullPath : item.path)}`;
+}
 function sameChipValue(left, right) {
     if (left.kind !== right.kind)
         return false;
     if (left.kind === "url" && right.kind === "url")
         return left.url === right.url;
     if ((left.kind === "file" || left.kind === "folder") && (right.kind === "file" || right.kind === "folder")) {
-        return path.normalize(left.path) === path.normalize(right.path);
+        return normalizedPathIdentity(left.path) === normalizedPathIdentity(right.path);
     }
     if (left.kind === "image" && right.kind === "image")
         return left.image.data === right.image.data;

package/dist/app/session-shell/prompt-suggestion-controller.d.ts

@@ -17,7 +17,7 @@ export interface ContextualPromptSuggestionControllerOptions {
 type DecisionIdentity = Omit<OwnedUiPromptSuggestionIdentity, "model"> & {
     readonly model: OwnedUiPromptSuggestionIdentity["model"] | null;
 };
-/** Prefetches one inert candidate; owns retirement even when a provider ignores abort. */
+/** Prefetches one inert candidate and owns one bounded settlement/retry recovery lifecycle. */
 export declare class ContextualPromptSuggestionController {
     #private;
     readonly options: ContextualPromptSuggestionControllerOptions;
@@ -26,12 +26,13 @@ export declare class ContextualPromptSuggestionController {
     setEnabled(enabled: boolean): void;
     skip(identity: DecisionIdentity, reason: SuggestionDecisionReason): void;
     consider(identity: OwnedUiPromptSuggestionIdentity, decision: boolean | SuggestionDecision): void;
-    settle(identity: OwnedUiPromptSuggestionIdentity): void;
+    /** Settles an existing prefetch or starts the first request when that eligible prefetch was missed. */
+    settle(identity: OwnedUiPromptSuggestionIdentity, decision?: boolean | SuggestionDecision): void;
     accept(): void;
     invalidate(): void;
-    /** Retires only a generating request; a prepared or available suggestion survives the draft edit. */
+    /** Retires generating or scheduled recovery; a prepared or available suggestion survives a draft edit. */
     abortPending(): void;
-    /** Reasserts retained ghost text after an editor mutation makes the prompt eligible again. */
+    /** Reasserts retained ghost text or retries a deferred presentation when the editor is eligible. */
     restoreAvailable(): void;
     dispose(): void;
 }