update_track_plan

Instructions

Implementation Reference

• src/tools/conductor.tool.ts:120-130 (handler)

  MCP tool handler for 'update_track_plan'. Receives trackName and content, calls the manager's updateTrackPlan, and returns the result as JSON.

  server.tool(
    'update_track_plan',
    'Overwrite the plan.md for an existing conductor track with new content. The track must already exist. Use this to update task status, add phases, or record decisions.',
    UpdateTrackPlanSchema.shape,
    async (args) => {
      const result = await manager.updateTrackPlan(args.trackName, args.content);
      return {
        content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
      };
    },
  );

• src/tools/conductor.tool.ts:27-30 (schema)

  Zod schema for update_track_plan inputs: trackName (non-empty string) and content (non-empty string).

  export const UpdateTrackPlanSchema = z.object({
    trackName: z.string().min(1),
    content: z.string().min(1),
  });

• src/managers/ConductorManager.ts:89-93 (handler)

  Manager logic for updateTrackPlan: validates the slug, delegates to FileSystemAccess.writeTrackPlan to write plan.md, returns result with length.

  async function updateTrackPlan(trackName: string, content: string): Promise<UpdateTrackPlanResult> {
    assertSafeSlug(trackName);
    await fs.writeTrackPlan(tracksDir, trackName, content);
    return { trackName, updated: true, length: content.length };
  }

• src/access/FileSystemAccess.ts:65-68 (helper)

  Low-level filesystem helper that writes content to <tracksDir>/<trackName>/plan.md.

  async function writeTrackPlan(tracksDir: string, trackName: string, content: string): Promise<void> {
    const planPath = join(tracksDir, trackName, 'plan.md');
    await writeFile(planPath, content, { encoding: 'utf8' });
  }

• src/index.ts:17-53 (registration)

  Top-level registration: imports and calls registerConductorTools, which registers 'update_track_plan' among other conductor tools.

  import { registerConductorTools } from './tools/conductor.tool.js';
  import { registerDevLifecycleTools } from './tools/dev-lifecycle.tool.js';
  
  import { createLogger } from './utilities/LoggingUtility.js';
  
  const log = createLogger('mempalace-mcp-dev');
  
  // --- Configuration (env-overridable) ---
  const REPO_DIR = resolve(process.env['MCP_REPO_DIR'] ?? process.cwd());
  const PALACE_DIR = resolve(process.env['MCP_PALACE_DIR'] ?? join(homedir(), '.mempalace', 'active'));
  const PALACE_WING = process.env['MCP_PALACE_WING'] ?? 'code';
  const LEDGER_PATH = resolve(process.env['MCP_LEDGER_PATH'] ?? join(REPO_DIR, '.mcp-dev', 'ledger.jsonl'));
  const TRACKS_DIR = resolve(process.env['MCP_TRACKS_DIR'] ?? join(REPO_DIR, 'conductor', 'tracks'));
  
  // --- Ensure required dirs exist ---
  const mcpDevDir = join(REPO_DIR, '.mcp-dev');
  if (!existsSync(mcpDevDir)) mkdirSync(mcpDevDir, { recursive: true });
  if (!existsSync(PALACE_DIR)) mkdirSync(PALACE_DIR, { recursive: true });
  
  // --- Compose Managers ---
  const codeSearchManager = createCodeSearchManager(PALACE_DIR, PALACE_WING, REPO_DIR);
  const ledgerManager = createLedgerManager(LEDGER_PATH, REPO_DIR);
  const branchManager = createBranchManager(REPO_DIR);
  const conductorManager = createConductorManager(TRACKS_DIR);
  const devLifecycleManager = createDevLifecycleManager(REPO_DIR);
  
  // --- MCP Server ---
  const server = new McpServer(
    { name: 'mempalace-mcp-dev', version: '1.0.0' },
  );
  
  // --- Register Tools (Clients in IDesign terms) ---
  registerCodeSearchTools(server, codeSearchManager, REPO_DIR);
  registerLedgerTools(server, ledgerManager);
  registerBranchTools(server, branchManager);
  registerConductorTools(server, conductorManager);
  registerDevLifecycleTools(server, devLifecycleManager);