gestalt-mobile 0.17.3 → 0.18.1

package/dist/server/server/platform/plans/filesystem-workspace-plan-catalog.js

@@ -9,14 +9,12 @@ import { parseSupervisedPlan } from '../../features/plans/application/parse-supe
 const maximumBytes = 1_048_576;
 /**
  * Passive access to every regular `.org` file below a workspace. Symlinks are
- * never followed, and every candidate must pass the installed Org Plan helper
- * before it is projected for the browser.
+ * never followed. Supported supervised plans include a browser preview; other
+ * Org files remain visible in the catalog without one.
  */
 export class FilesystemWorkspacePlanCatalog {
-    validator;
     filesystem;
-    constructor(validator, filesystem = { lstat, readdir, readFile, realpath, stat }) {
-        this.validator = validator;
+    constructor(filesystem = { lstat, readdir, readFile, realpath, stat }) {
         this.filesystem = filesystem;
     }
     async list(workspacePath) {
@@ -26,10 +24,21 @@ export class FilesystemWorkspacePlanCatalog {
         const planNames = await this.discover(workspace);
         const entries = [];
         for (const planName of planNames) {
-            const result = await this.readFromWorkspace(workspace, planName);
-            if (result.kind !== 'available')
+            const candidate = await this.readCandidate(workspace, planName);
+            if (candidate.kind === 'missing')
                 continue;
-            entries.push(toEntry(planName, result.plan));
+            if (candidate.kind === 'unavailable') {
+                entries.push(toFallbackEntry(planName));
+                continue;
+            }
+            const parsed = parseSupervisedPlan({
+                source: candidate.source,
+                planPath: candidate.canonicalPath,
+                workspacePath: workspace,
+            });
+            entries.push(parsed.kind === 'available'
+                ? toEntry(planName, parsed.plan)
+                : toFallbackEntry(planName, candidate.source));
         }
         return entries;
     }
@@ -94,6 +103,17 @@ export class FilesystemWorkspacePlanCatalog {
         return plans.sort((left, right) => left.localeCompare(right));
     }
     async readFromWorkspace(workspace, planName) {
+        const candidate = await this.readCandidate(workspace, planName);
+        if (candidate.kind !== 'readable')
+            return candidate;
+        const parsed = parseSupervisedPlan({
+            source: candidate.source,
+            planPath: candidate.canonicalPath,
+            workspacePath: workspace,
+        });
+        return parsed.kind === 'available' ? parsed : { kind: 'unavailable' };
+    }
+    async readCandidate(workspace, planName) {
         if (!isPlanPath(planName))
             return { kind: 'missing' };
         const path = resolve(workspace, ...planName.split('/'));
@@ -108,8 +128,6 @@ export class FilesystemWorkspacePlanCatalog {
                 toPlanName(relative(workspace, canonical)) !== planName)
                 return { kind: 'unavailable' };
             const source = await this.filesystem.readFile(canonical, 'utf8');
-            if (!(await this.validator.validate(workspace, canonical)))
-                return { kind: 'unavailable' };
             const after = await this.filesystem.stat(canonical);
             if (!after.isFile() ||
                 after.size !== before.size ||
@@ -117,8 +135,7 @@ export class FilesystemWorkspacePlanCatalog {
                 after.dev !== before.dev ||
                 after.mtimeMs !== before.mtimeMs)
                 return { kind: 'unavailable' };
-            const parsed = parseSupervisedPlan({ source, planPath: canonical, workspacePath: workspace });
-            return parsed.kind === 'available' ? parsed : { kind: 'unavailable' };
+            return { kind: 'readable', source, canonicalPath: canonical };
         }
         catch (error) {
             return error.code === 'ENOENT'
@@ -153,8 +170,22 @@ function toEntry(planName, plan) {
         ...(plan.subtitle === undefined ? {} : { subtitle: plan.subtitle }),
         ...(plan.date === undefined ? {} : { date: plan.date }),
         ...(plan.keywords === undefined ? {} : { keywords: plan.keywords }),
+        previewAvailable: true,
         totalSteps: plan.totalSteps,
         doneSteps: plan.doneSteps,
         allDone: plan.allDone,
     };
 }
+function toFallbackEntry(planName, source) {
+    const declaredTitle = source
+        ?.replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => /^#\+TITLE:(?:[ \t](.*))?$/i.exec(line)?.[1]?.trim())
+        .find((title) => title);
+    const filename = planName.split('/').at(-1) ?? planName;
+    return {
+        planName,
+        title: declaredTitle ?? filename.slice(0, -'.org'.length),
+        previewAvailable: false,
+    };
+}

package/dist/server/shared/contracts/org-plan-attention.js

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Versioned, bounded contract consumed by supervised Org Plan roles. */
+export const GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME = 'gestalt_org_plan_attention';
+export const orgPlanAttentionReasons = [
+    'planChange',
+    'hardBlock',
+    'missingDependency',
+    'permissionRequired',
+    'externalState',
+    'materialAmbiguity',
+];
+export const orgPlanAttentionResumeConditions = [
+    'userGuidance',
+    'planRevision',
+    'dependencyInstalled',
+    'permissionGranted',
+    'externalStateChanged',
+];
+export const gestaltOrgPlanAttentionDynamicTool = {
+    type: 'function',
+    name: GESTALT_ORG_PLAN_ATTENTION_TOOL_NAME,
+    description: 'Declare a genuine, durable human-attention requirement for a supervised Org Plan. Use only when progress cannot continue safely without the requested bounded human action. Do not include error stacks, environment values, plan contents, or unbounded prose.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['reason', 'summary', 'requestedAction', 'resumeCondition'],
+        properties: {
+            reason: { type: 'string', enum: orgPlanAttentionReasons },
+            summary: { type: 'string', minLength: 1, maxLength: 600 },
+            requestedAction: { type: 'string', minLength: 1, maxLength: 600 },
+            resumeCondition: { type: 'string', enum: orgPlanAttentionResumeConditions },
+        },
+    },
+};
+export function parseOrgPlanAttention(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 4)
+        return null;
+    if (!isReason(value.reason) ||
+        !isBoundedText(value.summary, 600) ||
+        !isBoundedText(value.requestedAction, 600) ||
+        !isResumeCondition(value.resumeCondition))
+        return null;
+    return {
+        reason: value.reason,
+        summary: value.summary,
+        requestedAction: value.requestedAction,
+        resumeCondition: value.resumeCondition,
+    };
+}
+export function parseOrgPlanAttentionResponse(value) {
+    if (!isRecord(value) || !['resume', 'disableAutopilot'].includes(value.action))
+        return null;
+    if (Object.keys(value).some((key) => key !== 'action' && key !== 'guidance'))
+        return null;
+    if (value.guidance !== undefined && !isBoundedText(value.guidance, 1_000))
+        return null;
+    return {
+        action: value.action,
+        ...(typeof value.guidance === 'string' ? { guidance: value.guidance } : {}),
+    };
+}
+/** The only result accepted by the held app-server dynamic-tool request. */
+export function toOrgPlanAttentionToolResponse(response) {
+    return {
+        success: true,
+        contentItems: [{ type: 'input_text', text: JSON.stringify(response) }],
+    };
+}
+export function isOrgPlanAttentionToolResponse(value) {
+    if (!isRecord(value) || value.success !== true || !Array.isArray(value.contentItems))
+        return false;
+    const item = value.contentItems[0];
+    if (value.contentItems.length !== 1 ||
+        !isRecord(item) ||
+        item.type !== 'input_text' ||
+        typeof item.text !== 'string')
+        return false;
+    try {
+        return parseOrgPlanAttentionResponse(JSON.parse(item.text)) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function isReason(value) {
+    return (typeof value === 'string' && orgPlanAttentionReasons.includes(value));
+}
+function isResumeCondition(value) {
+    return (typeof value === 'string' &&
+        orgPlanAttentionResumeConditions.includes(value));
+}
+function isBoundedText(value, maximum) {
+    return typeof value === 'string' && value.trim().length > 0 && value.length <= maximum;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.17.3",
+  "version": "0.18.1",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",