@xopcai/xopc 0.0.366 → 0.0.367

package/dist/src/config/models-json.d.ts

@@ -99,9 +99,33 @@ export declare const ImageGenerationCapabilitiesSchema: z.ZodObject<{
     }, z.core.$strict>>;
     edit: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
+        inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            png: "png";
+            jpeg: "jpeg";
+            webp: "webp";
+        }>>>;
+        maxInputBytes: z.ZodOptional<z.ZodNumber>;
         maxInputImages: z.ZodOptional<z.ZodNumber>;
         supportsSize: z.ZodOptional<z.ZodBoolean>;
         supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+        supportsResolution: z.ZodOptional<z.ZodBoolean>;
+        geometry: z.ZodOptional<z.ZodObject<{
+            sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "1K": "1K";
+                "2K": "2K";
+                "4K": "4K";
+            }>>>;
+            pixels: z.ZodOptional<z.ZodObject<{
+                minPixels: z.ZodNumber;
+                maxPixels: z.ZodNumber;
+                minEdge: z.ZodNumber;
+                maxEdge: z.ZodNumber;
+                step: z.ZodNumber;
+                maxRatio: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     geometry: z.ZodOptional<z.ZodObject<{
         sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -111,12 +135,22 @@ export declare const ImageGenerationCapabilitiesSchema: z.ZodObject<{
             "2K": "2K";
             "4K": "4K";
         }>>>;
+        pixels: z.ZodOptional<z.ZodObject<{
+            minPixels: z.ZodNumber;
+            maxPixels: z.ZodNumber;
+            minEdge: z.ZodNumber;
+            maxEdge: z.ZodNumber;
+            step: z.ZodNumber;
+            maxRatio: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
         qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             low: "low";
             high: "high";
             medium: "medium";
+            xhigh: "xhigh";
+            max: "max";
             auto: "auto";
         }>>>;
         formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -143,9 +177,33 @@ export declare const ImageGenerationModelSchema: z.ZodObject<{
         }, z.core.$strict>>;
         edit: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
+            inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                png: "png";
+                jpeg: "jpeg";
+                webp: "webp";
+            }>>>;
+            maxInputBytes: z.ZodOptional<z.ZodNumber>;
             maxInputImages: z.ZodOptional<z.ZodNumber>;
             supportsSize: z.ZodOptional<z.ZodBoolean>;
             supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+            supportsResolution: z.ZodOptional<z.ZodBoolean>;
+            geometry: z.ZodOptional<z.ZodObject<{
+                sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    "1K": "1K";
+                    "2K": "2K";
+                    "4K": "4K";
+                }>>>;
+                pixels: z.ZodOptional<z.ZodObject<{
+                    minPixels: z.ZodNumber;
+                    maxPixels: z.ZodNumber;
+                    minEdge: z.ZodNumber;
+                    maxEdge: z.ZodNumber;
+                    step: z.ZodNumber;
+                    maxRatio: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         geometry: z.ZodOptional<z.ZodObject<{
             sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -155,12 +213,22 @@ export declare const ImageGenerationModelSchema: z.ZodObject<{
                 "2K": "2K";
                 "4K": "4K";
             }>>>;
+            pixels: z.ZodOptional<z.ZodObject<{
+                minPixels: z.ZodNumber;
+                maxPixels: z.ZodNumber;
+                minEdge: z.ZodNumber;
+                maxEdge: z.ZodNumber;
+                step: z.ZodNumber;
+                maxRatio: z.ZodNumber;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
         output: z.ZodOptional<z.ZodObject<{
             qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 low: "low";
                 high: "high";
                 medium: "medium";
+                xhigh: "xhigh";
+                max: "max";
                 auto: "auto";
             }>>>;
             formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -218,9 +286,33 @@ export declare const ImageGenerationProviderSchema: z.ZodObject<{
             }, z.core.$strict>>;
             edit: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodBoolean;
+                inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    png: "png";
+                    jpeg: "jpeg";
+                    webp: "webp";
+                }>>>;
+                maxInputBytes: z.ZodOptional<z.ZodNumber>;
                 maxInputImages: z.ZodOptional<z.ZodNumber>;
                 supportsSize: z.ZodOptional<z.ZodBoolean>;
                 supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                supportsResolution: z.ZodOptional<z.ZodBoolean>;
+                geometry: z.ZodOptional<z.ZodObject<{
+                    sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        "1K": "1K";
+                        "2K": "2K";
+                        "4K": "4K";
+                    }>>>;
+                    pixels: z.ZodOptional<z.ZodObject<{
+                        minPixels: z.ZodNumber;
+                        maxPixels: z.ZodNumber;
+                        minEdge: z.ZodNumber;
+                        maxEdge: z.ZodNumber;
+                        step: z.ZodNumber;
+                        maxRatio: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
             geometry: z.ZodOptional<z.ZodObject<{
                 sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -230,12 +322,22 @@ export declare const ImageGenerationProviderSchema: z.ZodObject<{
                     "2K": "2K";
                     "4K": "4K";
                 }>>>;
+                pixels: z.ZodOptional<z.ZodObject<{
+                    minPixels: z.ZodNumber;
+                    maxPixels: z.ZodNumber;
+                    minEdge: z.ZodNumber;
+                    maxEdge: z.ZodNumber;
+                    step: z.ZodNumber;
+                    maxRatio: z.ZodNumber;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
             output: z.ZodOptional<z.ZodObject<{
                 qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                     low: "low";
                     high: "high";
                     medium: "medium";
+                    xhigh: "xhigh";
+                    max: "max";
                     auto: "auto";
                 }>>>;
                 formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -617,9 +719,33 @@ export declare const ProviderConfigSchema: z.ZodObject<{
                 }, z.core.$strict>>;
                 edit: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodBoolean;
+                    inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        png: "png";
+                        jpeg: "jpeg";
+                        webp: "webp";
+                    }>>>;
+                    maxInputBytes: z.ZodOptional<z.ZodNumber>;
                     maxInputImages: z.ZodOptional<z.ZodNumber>;
                     supportsSize: z.ZodOptional<z.ZodBoolean>;
                     supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                    supportsResolution: z.ZodOptional<z.ZodBoolean>;
+                    geometry: z.ZodOptional<z.ZodObject<{
+                        sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            "1K": "1K";
+                            "2K": "2K";
+                            "4K": "4K";
+                        }>>>;
+                        pixels: z.ZodOptional<z.ZodObject<{
+                            minPixels: z.ZodNumber;
+                            maxPixels: z.ZodNumber;
+                            minEdge: z.ZodNumber;
+                            maxEdge: z.ZodNumber;
+                            step: z.ZodNumber;
+                            maxRatio: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>>;
                 geometry: z.ZodOptional<z.ZodObject<{
                     sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -629,12 +755,22 @@ export declare const ProviderConfigSchema: z.ZodObject<{
                         "2K": "2K";
                         "4K": "4K";
                     }>>>;
+                    pixels: z.ZodOptional<z.ZodObject<{
+                        minPixels: z.ZodNumber;
+                        maxPixels: z.ZodNumber;
+                        minEdge: z.ZodNumber;
+                        maxEdge: z.ZodNumber;
+                        step: z.ZodNumber;
+                        maxRatio: z.ZodNumber;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>>;
                 output: z.ZodOptional<z.ZodObject<{
                     qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                         low: "low";
                         high: "high";
                         medium: "medium";
+                        xhigh: "xhigh";
+                        max: "max";
                         auto: "auto";
                     }>>>;
                     formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -866,9 +1002,33 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                     }, z.core.$strict>>;
                     edit: z.ZodOptional<z.ZodObject<{
                         enabled: z.ZodBoolean;
+                        inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            png: "png";
+                            jpeg: "jpeg";
+                            webp: "webp";
+                        }>>>;
+                        maxInputBytes: z.ZodOptional<z.ZodNumber>;
                         maxInputImages: z.ZodOptional<z.ZodNumber>;
                         supportsSize: z.ZodOptional<z.ZodBoolean>;
                         supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                        supportsResolution: z.ZodOptional<z.ZodBoolean>;
+                        geometry: z.ZodOptional<z.ZodObject<{
+                            sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                                "1K": "1K";
+                                "2K": "2K";
+                                "4K": "4K";
+                            }>>>;
+                            pixels: z.ZodOptional<z.ZodObject<{
+                                minPixels: z.ZodNumber;
+                                maxPixels: z.ZodNumber;
+                                minEdge: z.ZodNumber;
+                                maxEdge: z.ZodNumber;
+                                step: z.ZodNumber;
+                                maxRatio: z.ZodNumber;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>>;
                     geometry: z.ZodOptional<z.ZodObject<{
                         sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -878,12 +1038,22 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                             "2K": "2K";
                             "4K": "4K";
                         }>>>;
+                        pixels: z.ZodOptional<z.ZodObject<{
+                            minPixels: z.ZodNumber;
+                            maxPixels: z.ZodNumber;
+                            minEdge: z.ZodNumber;
+                            maxEdge: z.ZodNumber;
+                            step: z.ZodNumber;
+                            maxRatio: z.ZodNumber;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>>;
                     output: z.ZodOptional<z.ZodObject<{
                         qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                             low: "low";
                             high: "high";
                             medium: "medium";
+                            xhigh: "xhigh";
+                            max: "max";
                             auto: "auto";
                         }>>>;
                         formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{

package/dist/src/config/models-json.js

@@ -224,7 +224,7 @@ function saveModelsJson(path, config) {
 function modelsJsonExists(path = resolveModelsJsonPath()) {
 	return existsSync(path);
 }
-var OpenRouterRoutingSchema, VercelGatewayRoutingSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenAICompatSchema, ImageGenerationResolutionSchema, ImageGenerationQualitySchema, ImageGenerationOutputFormatSchema, ImageGenerationBackgroundSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, CustomModelSchema, ModelOverrideSchema, ProviderConfigSchema, ModelsJsonSchema, PROVIDER_ID_REGEX, RESERVED_PROVIDER_IDS;
+var OpenRouterRoutingSchema, VercelGatewayRoutingSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenAICompatSchema, ImageGenerationResolutionSchema, ImageGenerationQualitySchema, ImageGenerationOutputFormatSchema, ImageGenerationBackgroundSchema, ImageGeometrySchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, CustomModelSchema, ModelOverrideSchema, ProviderConfigSchema, ModelsJsonSchema, PROVIDER_ID_REGEX, RESERVED_PROVIDER_IDS;
 var init_models_json = __esmMin((() => {
 	init_src();
 	init_write_file_atomic();
@@ -277,6 +277,8 @@ var init_models_json = __esmMin((() => {
 		"low",
 		"medium",
 		"high",
+		"xhigh",
+		"max",
 		"auto"
 	]);
 	ImageGenerationOutputFormatSchema = z.enum([
@@ -289,6 +291,19 @@ var init_models_json = __esmMin((() => {
 		"opaque",
 		"auto"
 	]);
+	ImageGeometrySchema = z.object({
+		sizes: z.array(z.string().min(1)).optional(),
+		aspectRatios: z.array(z.string().min(1)).optional(),
+		resolutions: z.array(ImageGenerationResolutionSchema).optional(),
+		pixels: z.object({
+			minPixels: z.number().int().positive(),
+			maxPixels: z.number().int().positive(),
+			minEdge: z.number().int().positive(),
+			maxEdge: z.number().int().positive(),
+			step: z.number().int().positive(),
+			maxRatio: z.number().positive()
+		}).strict().optional()
+	}).strict();
 	ImageGenerationCapabilitiesSchema = z.object({
 		generate: z.object({
 			maxCount: z.number().int().positive().optional(),
@@ -298,15 +313,15 @@ var init_models_json = __esmMin((() => {
 		}).strict().optional(),
 		edit: z.object({
 			enabled: z.boolean(),
-			maxInputImages: z.number().int().positive().optional(),
+			inputFormats: z.array(ImageGenerationOutputFormatSchema).optional(),
+			maxInputBytes: z.number().int().positive().optional(),
+			maxInputImages: z.number().int().nonnegative().optional(),
 			supportsSize: z.boolean().optional(),
-			supportsAspectRatio: z.boolean().optional()
-		}).strict().optional(),
-		geometry: z.object({
-			sizes: z.array(z.string().min(1)).optional(),
-			aspectRatios: z.array(z.string().min(1)).optional(),
-			resolutions: z.array(ImageGenerationResolutionSchema).optional()
+			supportsAspectRatio: z.boolean().optional(),
+			supportsResolution: z.boolean().optional(),
+			geometry: ImageGeometrySchema.optional()
 		}).strict().optional(),
+		geometry: ImageGeometrySchema.optional(),
 		output: z.object({
 			qualities: z.array(ImageGenerationQualitySchema).optional(),
 			formats: z.array(ImageGenerationOutputFormatSchema).optional(),

package/dist/src/files/file-service.d.ts

@@ -34,6 +34,12 @@ export declare class FileSpaceService {
     list(): Promise<ResolvedFileSpace[]>;
     forContext(kind: 'agent' | 'project' | 'session', id: string): Promise<ResolvedFileSpace>;
     defaultSpace(): Promise<ResolvedFileSpace>;
+    /** Host spaces support explicit local file links without adding whole disks to discovery. */
+    private hostSpace;
+    resolveLocalResource(space: ResolvedFileSpace, candidate: string): Promise<{
+        resource: FileResource;
+        absolutePath?: string;
+    }>;
     get(id: string): Promise<ResolvedFileSpace>;
     resource(id: string): Promise<{
         space: ResolvedFileSpace;

package/dist/src/files/file-service.js

@@ -1,7 +1,7 @@
 import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
 import { resolveProjectAgentId } from "../projects/project-agent.js";
 import "../projects/index.js";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, parse, relative, resolve, sep } from "node:path";
 import { constants } from "node:fs";
 import { createHash } from "node:crypto";
 import { access, lstat, open, opendir, realpath, stat } from "node:fs/promises";
@@ -469,7 +469,42 @@ var FileSpaceService = class {
 	defaultSpace() {
 		return this.forContext("agent", resolveDefaultAgentId());
 	}
+	/** Host spaces support explicit local file links without adding whole disks to discovery. */
+	async hostSpace(path) {
+		const root = parse(resolve(path)).root;
+		return {
+			id: `host-${Buffer.from(root).toString("base64url")}`,
+			title: "Local files",
+			kind: "workspace",
+			bindings: [],
+			writable: false,
+			root
+		};
+	}
+	async resolveLocalResource(space, candidate) {
+		const absolutePath = await realpath(candidate).catch((error) => {
+			if (error.code === "ENOENT" || error.code === "ENOTDIR") throw new FileServiceError(404, "File not found");
+			if (error.code === "EACCES" || error.code === "EPERM") throw new FileServiceError(403, "File access denied");
+			throw error;
+		});
+		const info = await stat(absolutePath);
+		if (!info.isFile() && !info.isDirectory()) throw new FileServiceError(400, "Not a file or directory");
+		await access(absolutePath, constants.R_OK).catch(() => {
+			throw new FileServiceError(403, "File access denied");
+		});
+		if (isWithin(await realpath(space.root), absolutePath)) return { resource: await fileResourceFromPath(space, absolutePath) };
+		return {
+			resource: await fileResourceFromPath(await this.hostSpace(absolutePath), absolutePath),
+			absolutePath
+		};
+	}
 	async get(id) {
+		if (id.startsWith("host-")) {
+			const root = Buffer.from(id.slice(5), "base64url").toString("utf8");
+			const space = await this.hostSpace(root);
+			if (space.id !== id || space.root !== root) throw new FileServiceError(400, "Invalid host file space");
+			return space;
+		}
 		const hadCache = this.cache !== null;
 		let space = (await this.list()).find((item) => item.id === id);
 		if (!space && hadCache) {
@@ -483,6 +518,8 @@ var FileSpaceService = class {
 		const locator = parseFileResourceId(id);
 		const space = await this.get(locator.spaceId);
 		const absolutePath = await resolveFilePath(space.root, locator.relativePath);
+		const info = await stat(absolutePath);
+		if (!info.isFile() && !info.isDirectory()) throw new FileServiceError(400, "Not a file or directory");
 		return {
 			space,
 			resource: await fileResourceFromPath(space, absolutePath, resolve(space.root, locator.relativePath)),

package/dist/src/gateway/custom-image-providers.d.ts

@@ -36,9 +36,33 @@ export declare const CustomImageProviderInputSchema: z.ZodObject<{
                 }, z.core.$strict>>;
                 edit: z.ZodOptional<z.ZodObject<{
                     enabled: z.ZodBoolean;
+                    inputFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        png: "png";
+                        jpeg: "jpeg";
+                        webp: "webp";
+                    }>>>;
+                    maxInputBytes: z.ZodOptional<z.ZodNumber>;
                     maxInputImages: z.ZodOptional<z.ZodNumber>;
                     supportsSize: z.ZodOptional<z.ZodBoolean>;
                     supportsAspectRatio: z.ZodOptional<z.ZodBoolean>;
+                    supportsResolution: z.ZodOptional<z.ZodBoolean>;
+                    geometry: z.ZodOptional<z.ZodObject<{
+                        sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        resolutions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            "1K": "1K";
+                            "2K": "2K";
+                            "4K": "4K";
+                        }>>>;
+                        pixels: z.ZodOptional<z.ZodObject<{
+                            minPixels: z.ZodNumber;
+                            maxPixels: z.ZodNumber;
+                            minEdge: z.ZodNumber;
+                            maxEdge: z.ZodNumber;
+                            step: z.ZodNumber;
+                            maxRatio: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>>;
                 geometry: z.ZodOptional<z.ZodObject<{
                     sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -48,12 +72,22 @@ export declare const CustomImageProviderInputSchema: z.ZodObject<{
                         "2K": "2K";
                         "4K": "4K";
                     }>>>;
+                    pixels: z.ZodOptional<z.ZodObject<{
+                        minPixels: z.ZodNumber;
+                        maxPixels: z.ZodNumber;
+                        minEdge: z.ZodNumber;
+                        maxEdge: z.ZodNumber;
+                        step: z.ZodNumber;
+                        maxRatio: z.ZodNumber;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>>;
                 output: z.ZodOptional<z.ZodObject<{
                     qualities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                         low: "low";
                         high: "high";
                         medium: "medium";
+                        xhigh: "xhigh";
+                        max: "max";
                         auto: "auto";
                     }>>>;
                     formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{

package/dist/src/gateway/file-path-classifier.js

@@ -3,7 +3,8 @@ import { init_agent_scope, resolveAgentProfileDir } from "../agent/agent-scope.j
 import { init_paths, resolveConfigPath, resolveSkillsDir } from "../config/paths.js";
 import { extractProfileAgentId } from "../config/agent-profile.js";
 import { isBareProfileMarkdownFileName, resolveProfileMarkdownPathIfBareName } from "../agent/tools/tool-paths.js";
-import { isPathUnderWorkspace, resolveWorkspaceSafePath } from "./workspace-editor-path.js";
+import { isPathUnderWorkspace } from "./workspace-editor-path.js";
+import { homedir } from "node:os";
 import { basename, isAbsolute, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 //#region src/gateway/file-path-classifier.ts
@@ -72,15 +73,23 @@ async function resolveFileReferenceCandidate(rawPath, workspaceRoot, ctx) {
 		...ctx,
 		workspaceRoot: displayRoot
 	};
+	if (rawPath.includes("\0")) return {
+		candidate: null,
+		invalid: true
+	};
+	if (rawPath === "~" || rawPath.startsWith("~/")) return {
+		candidate: resolve(homedir(), rawPath.slice(2)),
+		invalid: false
+	};
 	if (looksLikeHostAbsolutePath(rawPath)) return {
 		candidate: resolve(rawPath),
 		invalid: false
 	};
-	const wsPath = resolveWorkspaceSafePath(workspaceRoot, rawPath);
-	if (!wsPath) return {
+	if (/^[a-z][a-z0-9+.-]*:/i.test(rawPath)) return {
 		candidate: null,
 		invalid: true
 	};
+	const wsPath = resolve(workspaceRoot, rawPath);
 	try {
 		await stat(wsPath);
 		return {

package/dist/src/gateway/hono/routes/files.js

@@ -1,4 +1,6 @@
+import { TaskRunRepository, init_task_run_repository } from "../../../tasks/task-run-repository.js";
 import { FileServiceError, fileResourceFromPath, parseFileResourceId, resolveFilePath } from "../../../files/file-service.js";
+import { buildFilePathClassifierContext, resolveFileReferenceCandidate } from "../../file-path-classifier.js";
 import { getGatewayFileSpaceService } from "../../file-space-service.js";
 import { getSessionPreparation } from "../../../storage/sqlite/session-creation-repository.js";
 import { fuzzySearchWorkspaceFiles, fuzzySubsequenceScore } from "../../workspace-file-search.js";
@@ -6,6 +8,7 @@ import { registerFileReferenceRoutes } from "./file-references.js";
 import { basename, join } from "node:path";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 //#region src/gateway/hono/routes/files.ts
+init_task_run_repository();
 const mutationLocks = /* @__PURE__ */ new Map();
 async function withMutationLock(key, action) {
 	const previous = mutationLocks.get(key) ?? Promise.resolve();
@@ -115,8 +118,16 @@ function registerFilesRoutes(authenticated, deps) {
 			const body = await c.req.json();
 			if (!body.spaceId || !body.path) throw new FileServiceError(400, "spaceId and path are required");
 			const space = await files.get(body.spaceId);
-			const absolutePath = await resolveFilePath(space.root, body.path);
-			return c.json({ resource: await fileResourceFromPath(space, absolutePath) });
+			const sourceConversationId = body.taskRunId ? new TaskRunRepository().get(body.taskRunId)?.conversationId : void 0;
+			if (body.taskRunId && !sourceConversationId) throw new FileServiceError(404, "Task file context not found");
+			const sourceSpace = sourceConversationId ? await files.forContext("session", sourceConversationId) : space;
+			const ctx = {
+				...buildFilePathClassifierContext(deps.service.currentConfig, sourceConversationId),
+				workspaceRoot: sourceSpace.root
+			};
+			const { candidate, invalid } = await resolveFileReferenceCandidate(body.path, sourceSpace.root, ctx);
+			if (!candidate || invalid) throw new FileServiceError(400, "Invalid file path");
+			return c.json(await files.resolveLocalResource(space, candidate));
 		} catch (error) {
 			return errorResponse(c, error);
 		}

package/dist/src/gateway/hono/routes/personal-agent.js

@@ -6,6 +6,8 @@ import { cancelPersonalRequest, personalRequestSnapshot, publishPersonalRequest
 import { PersonalOnboardingDraftSchema, PersonalOnboardingStepSchema, finishPersonalWelcome, getPersonalOnboarding, savePersonalOnboarding } from "../../../personal-agent/onboarding.js";
 import { PersonalAppearanceSchema, PersonalPreferencesSchema, createOrResumePersonalAgent, ensurePersonalConversationVisibility, listPersonalModels, patchPersonalProfile, refreshPersonalDelegationGuidance } from "../../../personal-agent/service.js";
 import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import { markPersonalRead, personalUnreadSnapshot } from "../../../personal-agent/unread.js";
+import { registerProactivityRoutes } from "../../../personal-agent/proactivity/routes.js";
 import { z } from "zod";
 //#region src/gateway/hono/routes/personal-agent.ts
 init_device_access_repository();
@@ -51,6 +53,7 @@ function registerPersonalAgentRoutes(authenticated, deps) {
 		const platform = getDevice(principal.deviceId)?.platform;
 		return platform === "harmonyos" || platform === "ios" || platform === "android" ? "local-owner" : null;
 	};
+	registerProactivityRoutes(authenticated, deps, owner);
 	authenticated.get("/api/personal-agent", async (c) => {
 		const ownerId = owner(c);
 		if (!ownerId) return c.json({
@@ -64,6 +67,44 @@ function registerPersonalAgentRoutes(authenticated, deps) {
 			payload: getPersonalAgent(ownerId)
 		});
 	});
+	authenticated.get("/api/personal-agent/unread", (c) => {
+		const ownerId = owner(c);
+		if (!ownerId) return c.json({
+			ok: false,
+			error: "Owner access is required"
+		}, 403);
+		const record = getPersonalAgent(ownerId);
+		return c.json({
+			ok: true,
+			payload: record ? personalUnreadSnapshot(record.conversationId) : null
+		});
+	});
+	authenticated.post("/api/personal-agent/read", async (c) => {
+		const ownerId = owner(c);
+		if (!ownerId) return c.json({
+			ok: false,
+			error: "Owner access is required"
+		}, 403);
+		const parsed = z.object({
+			transcriptId: z.string().min(1),
+			lastSeq: z.number().int().nonnegative()
+		}).strict().safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: "Invalid read snapshot"
+		}, 400);
+		const record = getPersonalAgent(ownerId);
+		if (!record) return c.json({
+			ok: false,
+			error: "Personal Agent is unavailable"
+		}, 404);
+		markPersonalRead(record.conversationId, parsed.data.transcriptId, parsed.data.lastSeq);
+		deps.service.emit("personal.unread.updated", { conversationId: record.conversationId });
+		return c.json({
+			ok: true,
+			payload: personalUnreadSnapshot(record.conversationId)
+		});
+	});
 	authenticated.get("/api/personal-agent/models", async (c) => {
 		if (!owner(c)) return c.json({
 			ok: false,

package/dist/src/gateway/service.d.ts

@@ -129,6 +129,7 @@ export declare class GatewayService {
     private createNotificationService;
     private readonly taskRunDispatch;
     private readonly taskMainUpdateDispatch;
+    private readonly personalProactivity;
     private readonly taskResultDispatch;
     dispatchTaskRuns(): void;
     ensureTaskConversation(taskId: string, options?: {