@assistkick/create 1.2.0 → 1.3.0

package/templates/assistkick-product-system/packages/backend/src/services/init.ts

@@ -12,9 +12,13 @@ import { PipelineStateStore } from '@assistkick/shared/lib/pipeline-state-store.
 import { PromptBuilder } from '@assistkick/shared/lib/prompt_builder.js';
 import { GitWorkflow } from '@assistkick/shared/lib/git_workflow.js';
 import { getDb } from '@assistkick/shared/lib/db.js';
-import { getKanbanEntry, saveKanbanEntry } from '@assistkick/shared/lib/kanban.js';
-import { getNode } from '@assistkick/shared/lib/graph.js';
+import { loadKanban, getKanbanEntry, saveKanbanEntry } from '@assistkick/shared/lib/kanban.js';
+import { readGraph, getNode } from '@assistkick/shared/lib/graph.js';
 import { WorkSummaryParser } from '@assistkick/shared/lib/work_summary_parser.js';
+import { PipelineOrchestrator } from '@assistkick/shared/lib/pipeline_orchestrator.js';
+import { GitHubAppService } from './github_app_service.js';
+import { ProjectWorkspaceService } from './project_workspace_service.js';
+import { ProjectService } from './project_service.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Navigate from packages/backend/src/services/ up to assistkick-product-system/
@@ -41,6 +45,9 @@ export const log = (tag: string, ...args: any[]) => {
 export let claudeService: any;
 export let pipeline: any;
 export let pipelineStateStore: any;
+export let orchestrator: PipelineOrchestrator;
+export let githubAppService: GitHubAppService;
+export let workspaceService: ProjectWorkspaceService;
 
 export const paths = {
   projectRoot: PROJECT_ROOT,
@@ -61,6 +68,58 @@ export const initServices = (verbose: boolean) => {
   const promptBuilder = new PromptBuilder({ paths, log });
   const gitWorkflow = new GitWorkflow({ claudeService, projectRoot: PROJECT_ROOT, worktreesDir: WORKTREES_DIR, log });
   const workSummaryParser = new WorkSummaryParser();
+
+  // New services for project git repo integration
+  githubAppService = new GitHubAppService({ log });
+  workspaceService = new ProjectWorkspaceService({ claudeService, projectRoot: PROJECT_ROOT, log });
+  const projectService = new ProjectService({ getDb, log });
+
+  /**
+   * Resolve a project-scoped workspace for the pipeline.
+   * Returns a GitWorkflow pointing to the project workspace + an afterMerge hook
+   * that pushes to the remote. Returns null if no workspace is configured.
+   */
+  const resolveProjectWorkspace = async (projectId: string) => {
+    const project = await projectService.getById(projectId);
+    if (!project) return null;
+
+    // Check if project has a workspace
+    if (!workspaceService.hasWorkspace(projectId)) {
+      // No workspace — use default behavior
+      return null;
+    }
+
+    const wsPath = workspaceService.getWorkspacePath(projectId);
+    const wsWorktreesDir = workspaceService.getWorktreesDir(projectId);
+
+    const projectGitWorkflow = new GitWorkflow({
+      claudeService,
+      projectRoot: wsPath,
+      worktreesDir: wsWorktreesDir,
+      log,
+    });
+
+    // Build afterMerge hook for pushing to remote
+    let afterMerge = null;
+    if (project.repoUrl && project.githubInstallationId && project.githubRepoFullName) {
+      afterMerge = async () => {
+        // Get a fresh token for push
+        const token = await githubAppService.getInstallationToken(project.githubInstallationId!);
+        const authUrl = `https://x-access-token:${token}@github.com/${project.githubRepoFullName}.git`;
+        await projectGitWorkflow.setRemoteUrl(authUrl);
+        try {
+          const branch = project.baseBranch || 'main';
+          await projectGitWorkflow.pushToRemote(branch);
+        } finally {
+          // Reset to non-authenticated URL
+          await projectGitWorkflow.setRemoteUrl(`https://github.com/${project.githubRepoFullName}.git`).catch(() => {});
+        }
+      };
+    }
+
+    return { gitWorkflow: projectGitWorkflow, afterMerge };
+  };
+
   pipeline = new Pipeline({
     promptBuilder,
     gitWorkflow,
@@ -71,6 +130,14 @@ export const initServices = (verbose: boolean) => {
     stateStore: pipelineStateStore,
     workSummaryParser,
     getNode,
+    resolveProjectWorkspace,
+  });
+
+  orchestrator = new PipelineOrchestrator({
+    pipeline,
+    loadKanban,
+    readGraph,
+    log,
   });
 
   // Mark any active pipeline states as interrupted (server restart recovery)

package/templates/assistkick-product-system/packages/backend/src/services/project_service.ts

@@ -17,6 +17,10 @@ export interface ProjectRecord {
   name: string;
   isDefault: number;
   archivedAt: string | null;
+  repoUrl: string | null;
+  githubInstallationId: string | null;
+  githubRepoFullName: string | null;
+  baseBranch: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -64,6 +68,10 @@ export class ProjectService {
       name,
       isDefault: 0,
       archivedAt: null,
+      repoUrl: null,
+      githubInstallationId: null,
+      githubRepoFullName: null,
+      baseBranch: null,
       createdAt: now,
       updatedAt: now,
     };
@@ -139,6 +147,69 @@ export class ProjectService {
     return { ...existing, archivedAt: null, updatedAt: now };
   };
 
+  /** Connect a git repository to a project (stores repo metadata). */
+  connectRepo = async (id: string, opts: {
+    repoUrl: string;
+    githubInstallationId?: string;
+    githubRepoFullName?: string;
+    baseBranch?: string;
+  }): Promise<ProjectRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Project not found');
+
+    const now = new Date().toISOString();
+    await db
+      .update(projects)
+      .set({
+        repoUrl: opts.repoUrl,
+        githubInstallationId: opts.githubInstallationId || null,
+        githubRepoFullName: opts.githubRepoFullName || null,
+        baseBranch: opts.baseBranch || null,
+        updatedAt: now,
+      })
+      .where(eq(projects.id, id));
+
+    this.log('PROJECTS', `Connected repo to project ${id}: ${opts.repoUrl}`);
+    return {
+      ...existing,
+      repoUrl: opts.repoUrl,
+      githubInstallationId: opts.githubInstallationId || null,
+      githubRepoFullName: opts.githubRepoFullName || null,
+      baseBranch: opts.baseBranch || null,
+      updatedAt: now,
+    };
+  };
+
+  /** Disconnect a git repository from a project. */
+  disconnectRepo = async (id: string): Promise<ProjectRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Project not found');
+
+    const now = new Date().toISOString();
+    await db
+      .update(projects)
+      .set({
+        repoUrl: null,
+        githubInstallationId: null,
+        githubRepoFullName: null,
+        baseBranch: null,
+        updatedAt: now,
+      })
+      .where(eq(projects.id, id));
+
+    this.log('PROJECTS', `Disconnected repo from project ${id}`);
+    return {
+      ...existing,
+      repoUrl: null,
+      githubInstallationId: null,
+      githubRepoFullName: null,
+      baseBranch: null,
+      updatedAt: now,
+    };
+  };
+
   ensureDefaultAndAssignOrphans = async (): Promise<void> => {
     const db = this.getDb();
 

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ProjectWorkspaceService } from './project_workspace_service.ts';
+import { join } from 'node:path';
+
+const PROJECT_ROOT = '/tmp/test-project-root';
+
+const createMockClaudeService = () => ({
+  spawnCommand: mock.fn(async () => ''),
+});
+
+const createService = (claudeService: any) => {
+  return new ProjectWorkspaceService({
+    claudeService,
+    projectRoot: PROJECT_ROOT,
+    log: mock.fn(),
+  });
+};
+
+describe('ProjectWorkspaceService', () => {
+  let claudeService: ReturnType<typeof createMockClaudeService>;
+  let service: ProjectWorkspaceService;
+
+  beforeEach(() => {
+    claudeService = createMockClaudeService();
+    service = createService(claudeService);
+  });
+
+  describe('getWorkspacePath', () => {
+    it('returns correct workspace path for a project', () => {
+      const path = service.getWorkspacePath('proj_abc123');
+      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123'));
+    });
+  });
+
+  describe('getWorktreesDir', () => {
+    it('returns correct worktrees dir inside workspace', () => {
+      const path = service.getWorktreesDir('proj_abc123');
+      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123', '.worktrees'));
+    });
+  });
+
+  describe('getDefaultBranch', () => {
+    it('parses symbolic-ref output correctly', async () => {
+      claudeService.spawnCommand = mock.fn(async (_cmd: string, args: string[]) => {
+        if (args.includes('symbolic-ref')) return 'origin/main\n';
+        return '';
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'main');
+    });
+
+    it('falls back to branch --show-current', async () => {
+      let callCount = 0;
+      claudeService.spawnCommand = mock.fn(async (_cmd: string, args: string[]) => {
+        callCount++;
+        if (args.includes('symbolic-ref')) throw new Error('no remote');
+        if (args.includes('--show-current')) return 'develop\n';
+        return '';
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'develop');
+    });
+
+    it('falls back to "main" when all methods fail', async () => {
+      claudeService.spawnCommand = mock.fn(async () => {
+        throw new Error('git failed');
+      });
+
+      const branch = await service.getDefaultBranch('proj_abc123');
+      assert.equal(branch, 'main');
+    });
+  });
+
+  describe('getStatus', () => {
+    it('returns hasWorkspace false when no .git directory', async () => {
+      // existsSync will return false for non-existent paths
+      const status = await service.getStatus('proj_nonexistent');
+      assert.equal(status.hasWorkspace, false);
+      assert.equal(status.hasRemote, false);
+      assert.equal(status.currentBranch, null);
+      assert.equal(status.remoteUrl, null);
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.ts

@@ -0,0 +1,194 @@
+/**
+ * ProjectWorkspaceService — manages per-project workspace directories.
+ * Each project gets a workspace at <projectRoot>/workspaces/<projectId>/.
+ * If a remote git repo is connected, it is cloned there.
+ * If not, git init creates a local repo so worktrees and branching always work.
+ */
+
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+
+interface ProjectWorkspaceServiceDeps {
+  claudeService: { spawnCommand: (cmd: string, args: string[], cwd: string) => Promise<string> };
+  projectRoot: string;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export class ProjectWorkspaceService {
+  private readonly claudeService: ProjectWorkspaceServiceDeps['claudeService'];
+  private readonly projectRoot: string;
+  private readonly log: ProjectWorkspaceServiceDeps['log'];
+
+  constructor({ claudeService, projectRoot, log }: ProjectWorkspaceServiceDeps) {
+    this.claudeService = claudeService;
+    this.projectRoot = projectRoot;
+    this.log = log;
+  }
+
+  /** Get the workspace directory path for a project. */
+  getWorkspacePath = (projectId: string): string => {
+    return join(this.projectRoot, 'workspaces', projectId);
+  };
+
+  /** Get the worktrees directory inside a project workspace. */
+  getWorktreesDir = (projectId: string): string => {
+    return join(this.getWorkspacePath(projectId), '.worktrees');
+  };
+
+  /** Check if a workspace exists and has a git repo. */
+  hasWorkspace = (projectId: string): boolean => {
+    const wsPath = this.getWorkspacePath(projectId);
+    return existsSync(join(wsPath, '.git'));
+  };
+
+  /** Ensure the workspace directory exists. Creates it if missing. */
+  private ensureDir = async (dir: string): Promise<void> => {
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  };
+
+  /** Initialize a new empty local git repository for a project. */
+  initWorkspace = async (projectId: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.ensureDir(wsPath);
+
+    if (existsSync(join(wsPath, '.git'))) {
+      this.log('WORKSPACE', `Workspace already has a git repo: ${wsPath}`);
+      return wsPath;
+    }
+
+    this.log('WORKSPACE', `Initializing git repo at ${wsPath}`);
+    await this.claudeService.spawnCommand('git', ['init'], wsPath);
+
+    // Create an initial commit so branches and worktrees work
+    await this.claudeService.spawnCommand('git', ['commit', '--allow-empty', '-m', 'Initial commit'], wsPath);
+    this.log('WORKSPACE', `Git repo initialized at ${wsPath}`);
+    return wsPath;
+  };
+
+  /** Clone a remote repository into the project workspace. */
+  cloneRepo = async (projectId: string, cloneUrl: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const parentDir = join(this.projectRoot, 'workspaces');
+    await this.ensureDir(parentDir);
+
+    // If workspace already exists, remove it first
+    if (existsSync(wsPath)) {
+      this.log('WORKSPACE', `Removing existing workspace before clone: ${wsPath}`);
+      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], parentDir);
+    }
+
+    this.log('WORKSPACE', `Cloning ${cloneUrl} into ${wsPath}`);
+    await this.claudeService.spawnCommand('git', ['clone', cloneUrl, wsPath], parentDir);
+    this.log('WORKSPACE', `Clone completed for project ${projectId}`);
+    return wsPath;
+  };
+
+  /** Get the default branch name of the workspace repo. */
+  getDefaultBranch = async (projectId: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    try {
+      // Try symbolic-ref for repos with a remote
+      const result = await this.claudeService.spawnCommand(
+        'git', ['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], wsPath,
+      );
+      // Returns e.g. "origin/main" — strip the "origin/" prefix
+      const branch = result.trim().replace(/^origin\//, '');
+      if (branch) return branch;
+    } catch {
+      // Fallback: try to get current branch name
+    }
+
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      const branch = result.trim();
+      if (branch) return branch;
+    } catch {
+      // Final fallback
+    }
+
+    return 'main';
+  };
+
+  /** Pull latest changes from the remote on the default branch. */
+  pullLatest = async (projectId: string, token?: string, repoFullName?: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    if (token && repoFullName) {
+      // Set up temporary credential for this pull
+      const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+      await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+    }
+
+    try {
+      const branch = await this.getDefaultBranch(projectId);
+      this.log('WORKSPACE', `Pulling latest on ${branch} for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['pull', 'origin', branch], wsPath);
+      this.log('WORKSPACE', `Pull completed for project ${projectId}`);
+    } catch (err: any) {
+      // Pull may fail if there's no remote or no upstream — that's OK for local-only repos
+      this.log('WORKSPACE', `Pull failed (non-fatal): ${err.message}`);
+    }
+
+    if (token && repoFullName) {
+      // Reset remote URL to non-authenticated form to avoid storing token
+      await this.claudeService.spawnCommand(
+        'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+      ).catch(() => {});
+    }
+  };
+
+  /** Push the default branch to the remote. */
+  pushToRemote = async (projectId: string, token: string, repoFullName: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getDefaultBranch(projectId);
+
+    // Set authenticated remote URL temporarily
+    const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+    await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+
+    try {
+      this.log('WORKSPACE', `Pushing ${branch} to remote for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['push', 'origin', branch], wsPath);
+      this.log('WORKSPACE', `Push completed for project ${projectId}`);
+    } finally {
+      // Reset to non-authenticated URL
+      await this.claudeService.spawnCommand(
+        'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+      ).catch(() => {});
+    }
+  };
+
+  /** Get workspace git status info. */
+  getStatus = async (projectId: string): Promise<{
+    hasWorkspace: boolean;
+    hasRemote: boolean;
+    currentBranch: string | null;
+    remoteUrl: string | null;
+  }> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    if (!existsSync(join(wsPath, '.git'))) {
+      return { hasWorkspace: false, hasRemote: false, currentBranch: null, remoteUrl: null };
+    }
+
+    let currentBranch: string | null = null;
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      currentBranch = result.trim() || null;
+    } catch {}
+
+    let remoteUrl: string | null = null;
+    let hasRemote = false;
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['remote', 'get-url', 'origin'], wsPath);
+      remoteUrl = result.trim() || null;
+      hasRemote = !!remoteUrl;
+    } catch {}
+
+    return { hasWorkspace: true, hasRemote, currentBranch, remoteUrl };
+  };
+}

package/templates/assistkick-product-system/packages/backend/src/services/pty_session_manager.test.ts

@@ -20,6 +20,8 @@ describe('PtySessionManager', () => {
   let logMock: ReturnType<typeof mock.fn>;
   let mockPty: ReturnType<typeof createMockPty>;
   const PROJECT_ROOT = '/test/project/root';
+  const PROJECT_ID = 'proj_test';
+  const PROJECT_NAME = 'Test Project';
 
   beforeEach(() => {
     mockPty = createMockPty();
@@ -29,12 +31,10 @@ describe('PtySessionManager', () => {
   });
 
   describe('spawnCommand uses projectRoot as cwd', () => {
-    it('passes projectRoot as cwd when spawning a command', () => {
-      manager.createSession('user1', 80, 24);
-
-      // Simulate typing "claude" + Enter
-      manager.writeToSession('user1', 'claude\r');
+    it('passes projectRoot as cwd when auto-launching claude', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
 
+      // Auto-launch is triggered on session creation
       assert.equal(spawnMock.mock.calls.length, 1);
       const spawnOptions = spawnMock.mock.calls[0].arguments[2] as Record<string, unknown>;
       assert.equal(spawnOptions.cwd, PROJECT_ROOT);
@@ -65,24 +65,95 @@ describe('PtySessionManager', () => {
   });
 
   describe('session lifecycle', () => {
-    it('creates a new session', () => {
-      const session = manager.createSession('user1', 80, 24);
-      assert.equal(session.userId, 'user1');
-      assert.equal(session.state, 'idle');
+    it('creates a new named session with project binding', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.projectId, PROJECT_ID);
+      assert.equal(session.projectName, PROJECT_NAME);
+      assert.equal(session.state, 'running'); // auto-launch sets state to running
+      assert.ok(session.id.startsWith('term_'));
+      assert.ok(session.name.startsWith(PROJECT_NAME));
     });
 
-    it('reuses existing session', () => {
-      const s1 = manager.createSession('user1', 80, 24);
-      const s2 = manager.createSession('user1', 80, 24);
-      assert.strictEqual(s1, s2);
+    it('creates separate sessions for the same project', () => {
+      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.notEqual(s1.id, s2.id);
     });
 
     it('destroys session and kills pty', () => {
-      manager.createSession('user1', 80, 24);
-      manager.writeToSession('user1', 'claude\r');
-      manager.destroySession('user1');
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      // session.pty is already set by auto-launch
+      manager.destroySession(session.id);
       assert.equal(mockPty.kill.mock.calls.length, 1);
-      assert.equal(manager.getSession('user1'), undefined);
+      assert.equal(manager.getSession(session.id), undefined);
+    });
+
+    it('lists all active sessions', () => {
+      const s1 = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      const s2 = manager.createSession('proj_other', 'Other', 80, 24);
+      const list = manager.listSessions();
+      assert.equal(list.length, 2);
+      assert.ok(list.some(s => s.id === s1.id));
+      assert.ok(list.some(s => s.id === s2.id));
+    });
+
+    it('session removed from list after destroy', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      manager.destroySession(session.id);
+      const list = manager.listSessions();
+      assert.equal(list.length, 0);
+    });
+  });
+
+  describe('auto-launch claude on session creation', () => {
+    it('auto-launches claude with --dangerously-skip-permissions and --append-system-prompt on session creation', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+
+      assert.equal(spawnMock.mock.calls.length, 1);
+      const [cmd, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.equal(cmd, 'claude');
+      assert.ok(args.includes('--dangerously-skip-permissions'));
+      assert.ok(args.includes('--append-system-prompt'));
+      assert.ok(args.includes(`We are working on project-id ${PROJECT_ID}`));
+    });
+
+    it('uses --append-system-prompt (not --system-prompt) to preserve default prompt', () => {
+      manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+
+      const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.ok(args.includes('--append-system-prompt'));
+      assert.ok(!args.includes('--system-prompt') || args.indexOf('--system-prompt') === args.indexOf('--append-system-prompt'));
+    });
+
+    it('includes the session projectId in the system prompt', () => {
+      const customProjectId = 'proj_custom_123';
+      manager.createSession(customProjectId, PROJECT_NAME, 80, 24);
+
+      const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      const promptIndex = args.indexOf('--append-system-prompt');
+      assert.ok(promptIndex !== -1);
+      assert.ok(args[promptIndex + 1].includes(customProjectId));
+    });
+
+    it('does not re-launch claude when reconnecting to an existing session', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      // Reconnect is simulated by getSession — no new spawn
+      const existing = manager.getSession(session.id);
+      assert.ok(existing);
+      assert.equal(spawnMock.mock.calls.length, 1);
+    });
+
+    it('session state is running immediately after creation', () => {
+      const session = manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.state, 'running');
+    });
+  });
+
+  describe('formatSessionName', () => {
+    it('formats session name as ProjectName - DD/MM/YY - HH:MM', () => {
+      const date = new Date(2026, 2, 6, 14, 30); // 2026-03-06 14:30
+      const name = manager.formatSessionName('My Project', date);
+      assert.equal(name, 'My Project - 06/03/26 - 14:30');
     });
   });
 });