fuli-context 0.7.5 → 0.7.7

package/src/server.js

@@ -51,22 +51,52 @@ export async function createServer(options = {}) {
     closeApplicationOnShutdown
   });
   const application = runtime.application;
-  const externalKnowledge = options.externalKnowledge ??
-    application.externalKnowledge ?? null;
-  const connectedKnowledge = options.connectedKnowledge ??
-    application.connectedKnowledge ?? null;
-  const system = options.system ?? (!app
-    ? createSystemService({
-        paths: resolveSetupPaths({
-          dataDir: dirname(localOptions.runtimeConfigPath),
-          packageRoot: PACKAGE_ROOT
-        }),
-        packageRoot: PACKAGE_ROOT,
-        activePort: port,
-        activeLan: lanEnabled,
-        executorAdapters: options.executorAdapters
-      })
-    : null);
+  let externalKnowledge;
+  let connectedKnowledge;
+  let system = null;
+  let resourcesClosing = null;
+  function closeResources() {
+    resourcesClosing ??= (async () => {
+      const failures = [];
+      for (const close of [() => system?.close?.(), () => runtime.close()]) {
+        try { await close(); } catch (error) { failures.push(error); }
+      }
+      if (failures.length === 1) throw failures[0];
+      if (failures.length > 1) {
+        throw new AggregateError(failures, 'Server resource shutdown failed');
+      }
+    })();
+    return resourcesClosing;
+  }
+  async function failStartup(error) {
+    try {
+      await closeResources();
+    } catch (cleanupError) {
+      throw new AggregateError([error, cleanupError],
+        `Server startup failed: ${error.message}; resource shutdown also failed`, { cause: error });
+    }
+    throw error;
+  }
+  try {
+    externalKnowledge = options.externalKnowledge ?? application.externalKnowledge ?? null;
+    connectedKnowledge = options.connectedKnowledge ?? application.connectedKnowledge ?? null;
+    system = options.system ?? (!app
+      ? createSystemService({
+          paths: resolveSetupPaths({
+            dataDir: dirname(localOptions.runtimeConfigPath),
+            packageRoot: PACKAGE_ROOT
+          }),
+          packageRoot: PACKAGE_ROOT,
+          activePort: port,
+          activeLan: lanEnabled,
+          executorAdapters: options.executorAdapters
+        })
+      : null);
+  } catch (error) {
+    // The owned application can already hold local databases before system
+    // construction or configuration validation fails, even without a listener.
+    await failStartup(error);
+  }
   for (let attempt = 0; attempt < 20; attempt += 1) {
     let authority = null;
     let allowedLanAuthorities = [];
@@ -82,6 +112,12 @@ export async function createServer(options = {}) {
         lanAuthorities: allowedLanAuthorities,
         lanAccessToken: lanToken
       }).catch((error) => {
+        if (response.headersSent || response.destroyed) {
+          // A post-response lease/storage failure cannot be converted into a second response.
+          if (!response.writableEnded) response.destroy();
+          console.error('Request failed after its response was committed or disconnected');
+          return;
+        }
         const mapped = mapHttpError(error);
         sendJson(response, mapped.status, mapped.body);
       });
@@ -90,15 +126,13 @@ export async function createServer(options = {}) {
     try {
       await listenServer(server, port, lanEnabled ? '0.0.0.0' : '127.0.0.1');
     } catch (error) {
-      runtime.close();
-      throw error;
+      await failStartup(error);
     }
     const address = server.address();
     if (isBlockedPort(address.port)) {
       await new Promise((resolveClose) => server.close(resolveClose));
       if (Number(port) === 0) continue;
-      runtime.close();
-      throw new Error(`Port ${address.port} is blocked for local fetch`);
+      await failStartup(new Error(`Port ${address.port} is blocked for local fetch`));
     }
     authority = localServerAuthority(address);
     allowedLanAuthorities = lanEnabled
@@ -106,24 +140,33 @@ export async function createServer(options = {}) {
       : [];
     if (!authority) {
       await new Promise((resolveClose) => server.close(resolveClose));
-      runtime.close();
-      throw new Error('Server did not bind to a valid local authority');
+      await failStartup(new Error('Server did not bind to a valid local authority'));
     }
 
+    let closing = null;
+    const close = () => {
+      closing ??= new Promise((resolve, reject) => {
+        server.close((error) => error && error.code !== 'ERR_SERVER_NOT_RUNNING'
+          ? reject(error) : resolve());
+      }).then(closeResources);
+      return closing;
+    };
     server.once('close', () => {
-      system?.close?.();
-      runtime.close();
+      // Legacy callers may close the raw HTTP server; still consume/report asynchronous failures.
+      void closeResources().catch((error) => {
+        if (!closing) console.error(`Server shutdown failed: ${error.message}`);
+      });
     });
     return {
       server,
+      close,
       url: `http://${authority}`,
       lanUrls: lanEnabled ? lanConsoleUrls(lanAddresses, address.port) : [],
       app: application
     };
   }
 
-  runtime.close();
-  throw new Error('Could not find a fetchable local port');
+  await failStartup(new Error('Could not find a fetchable local port'));
 }
 
 function resolveServerGraphOptions(options) {
@@ -178,14 +221,19 @@ async function runProgram(args) {
   const runtimeOptions = resolveGraphRuntimeOptions(args, process.env);
   const port = numberOption(args, '--port', DEFAULT_FULI_PORT);
   const lan = args.includes('--lan');
-  const { server, url, lanUrls } = await createServer({
+  const { server, close: closeRuntime, url, lanUrls } = await createServer({
     ...runtimeOptions,
     port,
     lan,
     lanAccessToken: lan ? process.env.FULI_LAN_ACCESS_TOKEN : null
   });
   const handlers = new Map();
-  const close = () => server.close();
+  const close = () => {
+    void closeRuntime().catch((error) => {
+      console.error(`Server shutdown failed: ${error.message}`);
+      process.exitCode = 1;
+    });
+  };
   for (const signal of ['SIGINT', 'SIGTERM']) {
     const handler = close;
     handlers.set(signal, handler);

package/src/setup/agent-installation-status.js

@@ -3,6 +3,13 @@ import { existsSync, readFileSync } from 'node:fs';
 import { replaceFuliTable } from './codex-config.js';
 import { isCodexBootstrapCurrent } from './codex-bootstrap.js';
 import { hasCurrentClaudeCodeHooks } from './claude-code-config.js';
+import {
+  hasCodexTomlHookDefinitions,
+  hasCurrentCodexLifecycleHooks,
+  hasCurrentCodexTomlLifecycleHooks,
+  withCodexTomlLifecycleHooks
+} from '../agents/codex/lifecycle-hooks.js';
+import { hasCurrentCursorLifecycleHooks } from '../agents/cursor/lifecycle-hooks.js';
 import { isSessionSkillCurrent } from './session-skill.js';
 import { readJsonFile } from '../storage/json-file.js';
 
@@ -30,7 +37,19 @@ export function inspectAgentInstallations(agents, context, {
       { fileExists, readText }
     );
     const claudeLifecycleCurrent = agent.id !== 'claude-code' ||
-      hasCurrentClaudeCodeHooks(readJson(agent.settingsPath));
+      hasCurrentClaudeCodeHooks(readJson(agent.settingsPath), {
+        hookTimeoutSec: context.hookTimeoutSec ?? 30
+      });
+    const codexConfig = agent.id === 'codex' && agent.hooksPath
+      ? readText(agent.configPath)
+      : '';
+    const lifecycleCurrent = agent.id === 'codex' && agent.hooksPath
+      ? hasCodexTomlHookDefinitions(codexConfig)
+        ? hasCurrentCodexTomlLifecycleHooks(codexConfig, { context })
+        : hasCurrentCodexLifecycleHooks(readJson(agent.hooksPath), { context })
+      : agent.id === 'cursor' && agent.hooksPath
+        ? hasCurrentCursorLifecycleHooks(readJson(agent.hooksPath), context)
+        : claudeLifecycleCurrent;
 
     let integrationStatus = 'not_connected';
     if (
@@ -38,6 +57,7 @@ export function inspectAgentInstallations(agents, context, {
       && skillsCurrent
       && codexBootstrapCurrent
       && claudeLifecycleCurrent
+      && lifecycleCurrent
     ) {
       integrationStatus = 'connected';
     }
@@ -52,8 +72,8 @@ export function inspectAgentInstallations(agents, context, {
         ...(agent.id === 'codex'
           ? { bootstrap: codexBootstrapCurrent ? 'current' : 'outdated' }
           : {}),
-        ...(agent.id === 'claude-code'
-          ? { lifecycleHooks: claudeLifecycleCurrent ? 'current' : 'outdated' }
+        ...(agent.id === 'claude-code' || agent.hooksPath
+          ? { lifecycleHooks: lifecycleCurrent ? 'current' : 'outdated' }
           : {})
       }
     };
@@ -75,9 +95,13 @@ function inspectRegistration(agent, context, readers) {
     if (agent.id === 'codex') {
       const current = readers.readText(agent.configPath);
       const present = /^\s*\[mcp_servers\.(?:fuli|"fuli"|'fuli')]/m.test(current);
+      const expectedConfig = replaceFuliTable(current, expected);
+      const normalizedExpected = hasCodexTomlHookDefinitions(current)
+        ? withCodexTomlLifecycleHooks(expectedConfig, { context })
+        : expectedConfig;
       return {
         present,
-        current: present && normalizeText(replaceFuliTable(current, expected)) ===
+        current: present && normalizeText(normalizedExpected) ===
           normalizeText(current)
       };
     }
@@ -108,9 +132,17 @@ function normalizeText(value) {
 }
 
 function defaultReadText(path) {
-  return existsSync(path) ? readFileSync(path, 'utf8') : '';
+  try {
+    return existsSync(path) ? readFileSync(path, 'utf8') : '';
+  } catch {
+    return '';
+  }
 }
 
 function defaultReadJson(path) {
-  return readJsonFile(path, {});
+  try {
+    return readJsonFile(path, {});
+  } catch {
+    return {};
+  }
 }

package/src/setup/agents.js

@@ -20,6 +20,8 @@ export function discoverAgents({
 } = {}) {
   const pathApi = platform === 'win32' ? path.win32 : path.posix;
   const codexHome = nonEmpty(env.CODEX_HOME) ?? pathApi.join(homeDir, '.codex');
+  const claudeHome = pathApi.join(homeDir, '.claude');
+  const cursorHome = pathApi.join(homeDir, '.cursor');
   const skillName = 'capturing-session-knowledge';
   const projectSkillName = 'grilling-project';
   return [
@@ -28,6 +30,7 @@ export function discoverAgents({
       label: 'Codex',
       command: 'codex',
       configPath: pathApi.join(codexHome, 'config.toml'),
+      hooksPath: pathApi.join(codexHome, 'hooks.json'),
       globalInstructionsPath: pathApi.join(codexHome, 'AGENTS.md'),
       globalInstructionsOverridePath: pathApi.join(codexHome, 'AGENTS.override.md'),
       skillPath: pathApi.join(homeDir, '.agents', 'skills', skillName),
@@ -39,19 +42,28 @@ export function discoverAgents({
       label: 'Claude Code',
       command: 'claude',
       configPath: pathApi.join(homeDir, '.claude.json'),
-      settingsPath: pathApi.join(homeDir, '.claude', 'settings.json'),
-      skillPath: pathApi.join(homeDir, '.claude', 'skills', skillName),
-      projectSkillPath: pathApi.join(homeDir, '.claude', 'skills', projectSkillName),
-      available: Boolean(commandExists('claude'))
+      settingsPath: pathApi.join(claudeHome, 'settings.json'),
+      skillPath: pathApi.join(claudeHome, 'skills', skillName),
+      projectSkillPath: pathApi.join(claudeHome, 'skills', projectSkillName),
+      available: Boolean(
+        commandExists('claude') ||
+        fileExists(pathApi.join(homeDir, '.claude.json')) ||
+        fileExists(claudeHome)
+      )
     },
     {
       id: 'cursor',
       label: 'Cursor',
       command: 'cursor',
-      configPath: pathApi.join(homeDir, '.cursor', 'mcp.json'),
-      skillPath: pathApi.join(homeDir, '.cursor', 'skills', skillName),
-      projectSkillPath: pathApi.join(homeDir, '.cursor', 'skills', projectSkillName),
-      available: Boolean(commandExists('cursor'))
+      configPath: pathApi.join(cursorHome, 'mcp.json'),
+      hooksPath: pathApi.join(cursorHome, 'hooks.json'),
+      skillPath: pathApi.join(cursorHome, 'skills', skillName),
+      projectSkillPath: pathApi.join(cursorHome, 'skills', projectSkillName),
+      available: Boolean(
+        commandExists('cursor') ||
+        fileExists(pathApi.join(cursorHome, 'mcp.json')) ||
+        fileExists(cursorHome)
+      )
     }
   ].map((agent) => adaptAgentForReviewSkill(agent, { homeDir, pathApi }));
 }

package/src/setup/claude-code-config.js

@@ -1,4 +1,5 @@
 import { existsSync } from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
 
 import {
   readJsonFile,
@@ -10,6 +11,12 @@ const MANAGED_HOOK_TOOLS = new Set([
   'begin_task_context',
   'verify_task_checkpoint'
 ]);
+const MANAGED_PERMISSION_RULES = Object.freeze([
+  // These allow model-initiated fallback restore/final checkpoint calls. Claude
+  // Code executes MCP lifecycle hooks separately from model tool permissions.
+  'mcp__fuli__get_collaboration_preferences',
+  'mcp__fuli__checkpoint_task_knowledge'
+]);
 
 export function connectClaudeCode(agent, context, {
   readConfig = readJsonFile,
@@ -21,6 +28,7 @@ export function connectClaudeCode(agent, context, {
   assertObject(settings, 'Claude Code settings');
   assertObject(current.mcpServers ?? {}, 'Claude Code mcpServers');
   assertHookSettings(settings.hooks ?? {});
+  assertPermissionSettings(settings.permissions ?? {});
 
   const next = {
     ...current,
@@ -81,7 +89,8 @@ export function disconnectClaudeCode(agent, {
     const settings = readConfig(agent.settingsPath, {});
     assertObject(settings, 'Claude Code settings');
     assertHookSettings(settings.hooks ?? {});
-    const nextSettings = withoutManagedHooks(settings);
+    assertPermissionSettings(settings.permissions ?? {});
+    const nextSettings = withoutManagedSettings(settings);
     if (!sameJson(settings, nextSettings)) {
       writeConfig(agent.settingsPath, nextSettings);
       changed = true;
@@ -95,26 +104,23 @@ export function disconnectClaudeCode(agent, {
   };
 }
 
-export function hasCurrentClaudeCodeHooks(settings) {
+export function hasCurrentClaudeCodeHooks(settings, { hookTimeoutSec = 30 } = {}) {
   try {
     assertObject(settings, 'Claude Code settings');
     assertHookSettings(settings.hooks ?? {});
+    assertPermissionSettings(settings.permissions ?? {});
+    return sameJson(
+      withManagedHooks(settings, { hookTimeoutSec }),
+      settings
+    );
   } catch {
     return false;
   }
-  return [
-    ['UserPromptSubmit', 'begin_task_context'],
-    ['Stop', 'verify_task_checkpoint']
-  ].every(([event, tool]) => (
-    (settings.hooks?.[event] ?? []).some((group) =>
-      group.hooks.some((hook) => isManagedHook(hook, tool))
-    )
-  ));
 }
 
 function withManagedHooks(settings, { hookTimeoutSec = 30 } = {}) {
   const normalizedHookTimeoutSec = positiveHookTimeout(hookTimeoutSec);
-  const clean = withoutManagedHooks(settings);
+  const clean = withoutManagedSettings(settings);
   const hooks = { ...(clean.hooks ?? {}) };
   hooks.UserPromptSubmit = [
     ...(hooks.UserPromptSubmit ?? []),
@@ -133,7 +139,32 @@ function withManagedHooks(settings, { hookTimeoutSec = 30 } = {}) {
       normalizedHookTimeoutSec
     )
   ];
-  return { ...clean, hooks };
+  return withManagedPermissions({ ...clean, hooks });
+}
+
+function withManagedPermissions(settings) {
+  const permissions = { ...(settings.permissions ?? {}) };
+  permissions.allow = [
+    ...(permissions.allow ?? []),
+    ...MANAGED_PERMISSION_RULES
+  ];
+  return { ...settings, permissions };
+}
+
+function withoutManagedSettings(settings) {
+  return withoutManagedPermissions(withoutManagedHooks(settings));
+}
+
+function withoutManagedPermissions(settings) {
+  if (!settings.permissions) return settings;
+  const permissions = { ...settings.permissions };
+  const remainingAllow = (permissions.allow ?? [])
+    .filter(rule => !MANAGED_PERMISSION_RULES.includes(rule));
+  if (remainingAllow.length) permissions.allow = remainingAllow;
+  else delete permissions.allow;
+  if (Object.keys(permissions).length) return { ...settings, permissions };
+  const { permissions: _removed, ...rest } = settings;
+  return rest;
 }
 
 function withoutManagedHooks(settings) {
@@ -197,6 +228,17 @@ function assertHookSettings(value) {
   }
 }
 
+function assertPermissionSettings(value) {
+  assertObject(value, 'Claude Code permissions');
+  for (const field of ['allow', 'ask', 'deny']) {
+    if (value[field] !== undefined && (
+      !Array.isArray(value[field]) || !value[field].every(rule => typeof rule === 'string')
+    )) {
+      throw new TypeError(`Claude Code permissions ${field} must be an array of strings`);
+    }
+  }
+}
+
 function assertObject(value, label) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     throw new TypeError(`${label} must be a JSON object`);
@@ -204,5 +246,5 @@ function assertObject(value, label) {
 }
 
 function sameJson(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
+  return isDeepStrictEqual(left, right);
 }

package/src/setup/codex-bootstrap.js

@@ -15,17 +15,18 @@ const BLOCK_START = '<!-- BEGIN FULI MANAGED INSTRUCTIONS -->';
 const BLOCK_END = '<!-- END FULI MANAGED INSTRUCTIONS -->';
 
 const GLOBAL_INSTRUCTIONS = `${BLOCK_START}
-At start of every user task, before any other tool or answer, call exactly
+At start of every user task, use \`begin_task_context\` hook context if supplied;
+do not repeat the fallback. Otherwise before any other tool or answer, call exactly
 \`get_collaboration_preferences\` with \`projectPath\`=current working directory,
-\`taskPrompt\`=current user request. Never substitute a project action/Fuli tool.
-Fuli never stores or returns them; inputs are transient. Apply all returned \`effective_preferences\`.
-Before asking user to repeat a stable project fact or method, inspect \`task_knowledge_recall\`.
-On miss call \`search_current_project_knowledge\` with focused action/artifact/target/identifier
-queries; never use the full request as the only query.
-Write tools enforce preferences in actual payload; mentioning later is not compliance.
-Resolve relevant \`deferred_conflict\` first; ignore others.
-Team: \`coordinate_project_agent_task\`; host \`acquire_runtime_lease\`, start workers, report
-execution, \`release_runtime_lease\` in finally.
+\`taskPrompt\`=current user request. Never substitute a project action.
+Fuli never stores or returns them. Apply all returned \`effective_preferences\`.
+Before reasking a stable project fact or method, inspect \`task_knowledge_recall\`.
+On miss: \`search_current_project_knowledge\`; focused action/artifact/target/identifier;
+never use the full request as the only query.
+Write tools: preferences in actual payload; mentioning later is not compliance.
+Resolve relevant \`deferred_conflict\`; ignore others.
+Team: \`coordinate_project_agent_task\`; \`acquire_runtime_lease\`, run/report workers,
+\`release_runtime_lease\` in finally.
 ${codexReviewCommandBridge()}
 ${BLOCK_END}`;
 

package/src/setup/codex-config.js

@@ -13,14 +13,27 @@ import {
   installCodexBootstrap,
   removeCodexBootstrap
 } from './codex-bootstrap.js';
+import {
+  hasCodexTomlHookDefinitions,
+  hasCurrentCodexTomlLifecycleHooks,
+  installCodexLifecycleHooks,
+  removeCodexLifecycleHooks,
+  withCodexTomlLifecycleHooks,
+  withoutCodexLifecycleHooks,
+  withoutCodexTomlLifecycleHooks
+} from '../agents/codex/lifecycle-hooks.js';
+import { readJsonFile, writeJsonFileAtomic } from '../storage/json-file.js';
 
 export function connectCodex(agent, context, {
   readConfig = readText,
   writeConfig = writeTextAtomic,
-  installBootstrap = installCodexBootstrap
+  readHooks = readJsonFile,
+  writeHooks = writeJsonFileAtomic,
+  installBootstrap = installCodexBootstrap,
+  installHooks = installCodexLifecycleHooks
 } = {}) {
   const current = readConfig(agent.configPath);
-  const next = replaceFuliTable(current, {
+  let next = replaceFuliTable(current, {
     command: context.nodePath,
     args: [
       context.mcpServerPath,
@@ -30,28 +43,75 @@ export function connectCodex(agent, context, {
       'codex'
     ]
   });
+  const tomlHooksPresent = Boolean(
+    agent.hooksPath && hasCodexTomlHookDefinitions(current)
+  );
+  const currentHooks = agent.hooksPath ? readHooks(agent.hooksPath, {}) : null;
+  const remainingHooks = currentHooks === null
+    ? null
+    : withoutCodexLifecycleHooks(currentHooks);
+  if (tomlHooksPresent && hasHookDefinitions(remainingHooks)) {
+    throw new Error(
+      'Codex has unrelated hooks in both config.toml and hooks.json; ' +
+      'Fuli cannot safely choose one representation automatically.'
+    );
+  }
+
   const bootstrap = installBootstrap(agent, context);
+  let hooks;
+  let hooksJsonWrite = null;
+  if (tomlHooksPresent) {
+    const withHooks = withCodexTomlLifecycleHooks(next, { context });
+    const jsonChanged = JSON.stringify(currentHooks) !== JSON.stringify(remainingHooks);
+    const tomlHooksChanged = !hasCurrentCodexTomlLifecycleHooks(current, {
+      context
+    });
+    hooks = {
+      changed: tomlHooksChanged || jsonChanged,
+      trustReviewRequired: tomlHooksChanged || jsonChanged
+    };
+    next = withHooks;
+    if (jsonChanged) hooksJsonWrite = remainingHooks;
+  } else {
+    hooks = installHooks(agent, { context });
+  }
   const registrationChanged = next !== current;
   if (registrationChanged) writeConfig(agent.configPath, next);
+  if (hooksJsonWrite !== null) writeHooks(agent.hooksPath, hooksJsonWrite);
   return {
     id: agent.id,
     label: agent.label,
     status: 'connected',
-    newTaskRequired: registrationChanged || bootstrap.changed === true
+    newTaskRequired: registrationChanged || bootstrap.changed === true || hooks.changed === true,
+    ...(hooks.trustReviewRequired === true ? { trustReviewRequired: true } : {}),
+    ...(agent.hooksPath ? {
+      nextSteps: [hooks.trustReviewRequired === true
+        ? 'Review and trust Fuli hooks in the Codex CLI with /hooks ' +
+          'before relying on automatic task entry.'
+        : 'Check Fuli hooks in the Codex CLI with /hooks; setup does not verify hook trust.']
+    } : {})
   };
 }
 
+function hasHookDefinitions(value) {
+  if (!value || Array.isArray(value) || typeof value !== 'object') return false;
+  if (!value.hooks || Array.isArray(value.hooks) || typeof value.hooks !== 'object') return false;
+  return Object.values(value.hooks).some((groups) => Array.isArray(groups) && groups.length > 0);
+}
+
 export function disconnectCodex(agent, {
   fileExists = existsSync,
   readConfig = readText,
   writeConfig = writeTextAtomic,
-  removeBootstrap = removeCodexBootstrap
+  removeBootstrap = removeCodexBootstrap,
+  removeHooks = removeCodexLifecycleHooks
 } = {}) {
   const bootstrap = removeBootstrap(agent);
+  const hooks = removeHooks(agent);
   let registrationChanged = false;
   if (fileExists(agent.configPath)) {
     const current = readConfig(agent.configPath);
-    const next = removeFuliTables(current);
+    const next = removeFuliTables(withoutCodexTomlLifecycleHooks(current));
     if (next !== current) {
       writeConfig(agent.configPath, next);
       registrationChanged = true;
@@ -60,7 +120,7 @@ export function disconnectCodex(agent, {
   return {
     id: agent.id,
     label: agent.label,
-    status: registrationChanged || bootstrap.changed ? 'disconnected' : 'not_connected'
+    status: registrationChanged || bootstrap.changed || hooks.changed ? 'disconnected' : 'not_connected'
   };
 }
 
@@ -88,7 +148,7 @@ export function removeFuliTables(source) {
   let removed = false;
 
   for (const line of lines) {
-    const header = /^\s*\[([^\]]+)]\s*(?:#.*)?$/.exec(line)?.[1]?.trim();
+    const header = tomlHeaderName(line);
     if (header) {
       skipping = isFuliTable(header);
       if (skipping) removed = true;
@@ -101,6 +161,13 @@ export function removeFuliTables(source) {
   return kept.length ? `${kept.join('\n')}\n` : '';
 }
 
+function tomlHeaderName(line) {
+  return (
+    /^\s*\[\[([^\]]+)]]\s*(?:#.*)?$/.exec(line)?.[1] ??
+    /^\s*\[([^\]]+)]\s*(?:#.*)?$/.exec(line)?.[1]
+  )?.trim();
+}
+
 function isFuliTable(header) {
   return /^mcp_servers\.(?:fuli|"fuli"|'fuli')(?:\.|$)/.test(header);
 }

package/src/setup/config-backup.js

@@ -1,4 +1,5 @@
 import {
+  chmodSync,
   copyFileSync,
   existsSync,
   mkdirSync
@@ -10,16 +11,30 @@ export function backupAgentConfig(agent, {
   now = () => new Date(),
   fileExists = existsSync,
   makeDirectory = mkdirSync,
-  copyFile = copyFileSync
+  copyFile = copyFileSync,
+  setMode = chmodSync
 }) {
   const sources = [
     { path: agent.configPath, suffix: '' },
     ...(agent.settingsPath
       ? [{ path: agent.settingsPath, suffix: '-settings' }]
+      : []),
+    ...(agent.hooksPath
+      ? [{ path: agent.hooksPath, suffix: '-hooks' }]
+      : []),
+    ...(agent.globalInstructionsPath
+      ? [{ path: agent.globalInstructionsPath, suffix: '-instructions' }]
+      : []),
+    ...(agent.globalInstructionsOverridePath
+      ? [{
+          path: agent.globalInstructionsOverridePath,
+          suffix: '-instructions-override'
+        }]
       : [])
   ].filter(({ path }) => path && fileExists(path));
   if (sources.length === 0) return null;
-  makeDirectory(backupDir, { recursive: true });
+  makeDirectory(backupDir, { recursive: true, mode: 0o700 });
+  setMode(backupDir, 0o700);
   const timestamp = now().toISOString().replaceAll(':', '-').replaceAll('.', '-');
   const backups = sources.map(({ path, suffix }) => {
     const extension = extname(path) || '.bak';
@@ -28,6 +43,7 @@ export function backupAgentConfig(agent, {
       `${agent.id}${suffix}-${timestamp}${extension}`
     );
     copyFile(path, backupPath);
+    setMode(backupPath, 0o600);
     return { path, backupPath };
   });
   return (