baton-issue-tracker 1.13.2 → 1.13.4

package/README.md

@@ -1,14 +1,84 @@
-# Fantastic Four
+<p align="center">
+  <img src="./admin/branding/teamLogo.png" width="100">
+</p>
 
-## Documentation
-- [User Guide](docs/USER_GUIDE.md) — How to use Baton CLI.
-- [Developer Guide](docs/CONTRIBUTING.md) — Setting up the development environment.
+# Baton Issue Tracker (Baton)
 
-## Project Details: 
-TBD
+[![NPM Version](https://img.shields.io/npm/v/baton-issue-tracker)](https://www.npmjs.com/package/baton-issue-tracker)
 
-# Team Page
-[Click Here](/admin/team.md)
+**Baton** is a terminal-first issue tracker designed for the modern AI-augmented software engineering workflow. It provides a structured interface for human supervisors to manage, track, and approve tasks performed by autonomous AI agents.
 
-# Agile: Team Status Video
-[https://youtu.be/xToi68JAcwk](https://youtu.be/xToi68JAcwk)
+In an environment where AI does much of the heavy lifting, Baton ensures accountability, tracks token budgets, and maintains a rigorous audit trail of every change made to your project's backlog.
+
+**Baton** is developed and maintained by **Team Fantastic Four**.
+
+--- 
+
+## Quickstart
+
+Get up and running with Baton in seconds.
+
+### 1. Installation
+Install Baton globally via NPM:
+```bash
+npm install -g baton-issue-tracker
+```
+
+### 2. Initialization
+Initialize a new tracker in your project root. This creates a local SQLite database at `.baton/baton.db`.
+```bash
+baton init
+```
+
+### 3. Check Identity
+Verify your registration or add yourself to the project:
+```bash
+baton whoami
+# If not registered:
+baton register --name "your-name" --type human
+```
+
+### 4. Basic Workflow
+* **Create a task:** `baton create --title "Fix login bug" --priority high`
+* **Check status:** `baton status`
+* **Claim next task (for agents):** `baton claim`
+* **Submit work (for agents):** `baton submit <id>`
+* **Approve work (for humans):** `baton approve <id>`
+
+---
+
+## Features
+
+*   **AI-Native API:** All commands support a `--json` flag for easy integration with AI agent loops.
+*   **Human-in-the-Loop:** A strict state machine ensuring agents can only resolve issues with human approval.
+*   **Full Activity History:** Track every edit, status change, and assignment with `baton log`.
+*   **Token Management:** Assign token limits to specific issues to control agent costs.
+*   **Zero-Config Storage:** Fully local SQLite storage—no external servers required.
+
+---
+
+## Documentation Index
+
+Baton is extensively documented to help both humans and agents get the most out of the system:
+
+### **Guides**
+*   [**CLI Reference**](./docs/cli/README.md): Detailed documentation for every command and flag.
+*   [**Setup & Workflow**](./docs/cli/setup-commands.md): How to initialize and manage the agent work-loop.
+*   [**Issue Management**](./docs/cli/issue-commands.md): Deep dive into ticket CRUD and review processes.
+*   [**Contributing**](./CONTRIBUTING.md): Guidelines for developing and extending Baton.
+
+### **Specifications**
+*   [**Product Requirements**](./docs/specs/project-requirements.md): The functional goals of the project.
+*   [**Data Model**](./docs/specs/issue-data-model.md): Detailed schema for issues and activity logs.
+*   [**ADRs (Architecture Decisions)**](./docs/adr/): Why we built Baton the way we did.
+
+---
+
+## Team
+Baton is developed and maintained by **Team Fantastic Four** (CSE 110, SP26). 
+Meet the team on our [**Team Page**](./admin/team.md).
+
+---
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baton-issue-tracker",
-  "version": "1.13.2",
+  "version": "1.13.4",
   "description": "A CLI issue tracker for AI agents",
   "type": "module",
   "bin": {

package/source/cli.js

@@ -28,6 +28,7 @@ import { run as runRegister } from './commands/register.js';
 import { run as runAgents } from './commands/agents.js';
 import { run as runWhoami } from './commands/whoami.js';
 import { run as runSubmit } from './commands/submit.js';
+import { run as runUnassign } from './commands/unassign.js';
 import { run as runUnclaim } from './commands/unclaim.js';
 import { run as runClaim } from './commands/claim.js';
 
@@ -56,6 +57,7 @@ Commands:
   update   Updates an issue's specified fields
   delete   Deletes an issue
   log      Show activity history for an issue
+  unassign Removes all assignees from issue
 
 Options:
   init --force                    Re-initialize an existing tracker database
@@ -94,6 +96,7 @@ Options:
   update --json                   Output as JSON (for AI agents)
   delete <id> [--yes]
   log <id> [--json]
+  unassign <id> [--json]          Output as JSON (for AI agents)
 
 Examples:
   baton init
@@ -120,6 +123,8 @@ Examples:
   baton update 3 --title "Revised title"
   baton update 7 --status closed --priority medium
   baton log 5
+  baton unassign 12
+  baton unassign 11 --json
 `;
 
 /**
@@ -136,7 +141,7 @@ async function main() {
   }
 
   // Authenticate the user and context before executing any command.
-  authenticateContext(command);
+  authenticateContext(command, args);
 
   const handlers = {
     init: () => runInit(args),
@@ -156,6 +161,7 @@ async function main() {
     delete: () => runDelete(args),
     log: () => runLog(args),
     submit: () => runSubmit(args),
+    unassign: () => runUnassign(args),
     unclaim: () => runUnclaim(args),
   };
 

package/source/commands/create.js

@@ -14,6 +14,7 @@
 //   --description <text>   Issue description
 //   --priority <level>     low | medium | high  (default: low)
 //   --token-limit <n>      Optional token budget for this issue
+//   --assignee <name>      Agent assigned to this issue
 //   -h, --help             Show this help
 
 import { createIssue } from "../services/issuesService.js";
@@ -24,8 +25,9 @@ import { spawnSync } from "child_process";
 import { writeFileSync, readFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
+import { listAgents, getAgentByName } from '../services/agentsService.js';
 
-const ALLOWED_CREATE_FIELDS = ['title', 'priority', 'tokenLimit', 'description'];
+const ALLOWED_CREATE_FIELDS = ['title', 'priority', 'tokenLimit', 'description', 'assigneeId'];
 
 const VALID_FLAGS = new Set([
   ...ALLOWED_CREATE_FIELDS.map(key => issueSchema[key].flag),
@@ -157,6 +159,19 @@ async function runInteractiveMode() {
     description = await openEditorForDescription();
   }
 
+  // Assignee
+  const agents = listAgents();
+  const assigneeChoices = [
+    { name: '(none)', value: null },
+    ...agents.map(a => ({ name: `${a.name} (${a.type})`, value: a.id }))
+  ];
+
+  const assigneeId = await select({
+    message: 'Assign to:',
+    choices: assigneeChoices,
+    default: null,
+  });
+
   // Preview & confirm
   console.log("\n" + "-".repeat(48));
   console.log(`  Title      : ${title}`);
@@ -181,7 +196,7 @@ async function runInteractiveMode() {
     process.exit(0);
   }
 
-  return { title, priority, tokenLimit, description };
+  return { title, priority, tokenLimit, description, assigneeId };
 }
 
 /**
@@ -217,6 +232,17 @@ export async function run(args) {
       ? await runInteractiveMode()
       : parseArgs(args);
 
+    // Getting agent name from ID
+    if (options.assigneeId) {
+      const target = getAgentByName(options.assigneeId);
+      if (!target) {
+        const agents = listAgents();
+        const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+        throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+      }
+      options.assigneeId = target.id;
+    }
+
     const issue = await createIssue(options);
     const envelope = { status: "success", issue: serializeIssue(issue) };
 

package/source/commands/init.js

@@ -11,7 +11,7 @@
 //  baton init --specs ./path/to/my-specs.md
 //  baton init --specs C:\full\path\to\specs.md
 
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { initDB } from '../db/index.js';
 import { Priority } from '../models/issue.js';
@@ -156,6 +156,21 @@ export async function run(args = []) {
     clearAllIssues();
   }
 
+  const templatePath = join('docs', 'BATON_AGENT_RULES.md');
+
+  let rulesContent = '';
+  if (existsSync(templatePath)) {
+    rulesContent = readFileSync(templatePath, 'utf8');
+  }
+
+  const outputPath = join(process.cwd(), 'BATON_AGENT_RULES.md');
+  if (existsSync(outputPath) && !flags.force) {
+    console.error('Error: BATON_AGENT_RULES.md already exists. Use --force to overwrite.');
+    return 1;
+  }
+
+  writeFileSync(outputPath, rulesContent, 'utf8');
+
   const resolvedSpecsPath = resolvePath(flags.specs, DEFAULT_SPECS_PATH);
   const createdIssues = generateIssuesFromSpecs(flags.specs);
   const envelope = {
@@ -180,4 +195,4 @@ export async function run(args = []) {
   });
 
   return 0;
-}
+}

package/source/commands/list.js

@@ -8,13 +8,15 @@
 //  --priority <p>    Filter by priority: low | medium | high
 //  --limit <n>       Max results (default: 50)
 //  --offset <n>      Skip first n results (default: 0)
+//  --assignee <name> Filter by assignee name
 //  --json            Output as JSON (for AI agents)
 //  -h, --help        Show this help
 
 import { listIssues } from '../services/issuesService.js';
+import { issueSchema } from '../models/schema.js';
+import { listAgents, getAgentByName } from '../services/agentsService.js';
+
 import {
-  getFlagValue,
-  getNumericFlag,
   hasFlag,
   parseArgs,
   printIssueTable,
@@ -23,6 +25,13 @@ import {
   serializeIssue,
 } from '../util.js';
 
+const ALLOWED_LIST_FIELDS = ['status', 'priority', 'limit', 'offset', 'assigneeId'];
+
+const VALID_FLAGS = new Set([
+  ...ALLOWED_LIST_FIELDS.map(key => issueSchema[key].flag),
+  '--json',
+]);
+
 /**
  * Lists issues matching the filters and pagination settings 
  * @param {string[]} args - The command line arguments
@@ -31,19 +40,26 @@ import {
 
 export async function run(args) {
     const isJson = hasFlag(args, '--json');
-    const validFlags = ['--status', '--priority', '--limit', '--offset', '--json'];
-    // Check if user misspelled a flag
     for (const arg of args) {
-        if (arg.startsWith('--')) {
-            if (!validFlags.includes(arg)) {
-                throw new Error(`Unknown flag provided: ${arg}. \nFlags: --status <s>, --priority <p>, --limit <n>, --offset <n>, --json`);
-            }
+        if (arg.startsWith('--') && !VALID_FLAGS.has(arg)) {
+            throw new Error(`Unknown flag provided: ${arg}.\nFlags: ${[...VALID_FLAGS].join(', ')}`);
         }
     }
 
     try {
         const options = parseArgs(args);
 
+        // Getting agent name from ID
+        if (options.assigneeId) {
+            const target = getAgentByName(options.assigneeId);
+            if (!target) {
+            const agents = listAgents();
+            const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+            throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+            }
+            options.assigneeId = target.id;
+        }
+
         const result = await listIssues(options);
         const issues = result.map(serializeIssue);
         const envelope = { status: 'success', count: issues.length, issues };

package/source/commands/log.js

@@ -22,8 +22,9 @@ function serializeLogEntry(entry) {
   return {
     log_id: entry.logId,
     issue_id: entry.issueId,
+    actor_id: entry.actorId,
     action: entry.action,
-    details: entry.details ?? null,
+    details: entry.details,
     created_at: entry.createdAt,
   };
 }

package/source/commands/unassign.js

@@ -0,0 +1,95 @@
+// unassign.js
+// AI was consulted to generate the majority of the contents of this file.
+// However, a human has reviewed and editted the generated code.
+// Removes the current assignee from an issue.
+//
+// Usage:
+//   baton unassign <id> [--json]
+//
+// Examples:
+//   baton unassign 12
+//   baton unassign 12 --json
+
+import { getIssue, unassignIssue } from "../services/issuesService.js";
+import { getCurrentActor } from "../services/context.js";
+import { AgentType } from "../models/agents.js";
+import { hasFlag, renderOutput, renderError, serializeIssue } from "../util.js";
+
+const VALID_FLAGS = new Set(["--json"]);
+
+/**
+ * Removes the current assignee from an issue.
+ * @param {string[]} args - The command-line arguments
+ * @returns {Promise<number>} The exit code: 0 is success, 1 is error
+ */
+export async function run(args) {
+  const isJson = hasFlag(args, "--json");
+
+  // Validate flags
+  const providedFlags = args.filter((a) => a.startsWith("--"));
+  for (const flag of providedFlags) {
+    if (!VALID_FLAGS.has(flag)) {
+      throw new Error(`Unknown flag: ${flag}`);
+    }
+  }
+
+  const idArg = args.find((a) => !a.startsWith("-"));
+  const issueId = Number(idArg);
+
+  if (!Number.isInteger(issueId) || issueId <= 0) {
+    renderError(
+      isJson,
+      `Invalid ID "${idArg}". ID must be a positive integer.`,
+      "INVALID_ID",
+    );
+    return 1;
+  }
+
+  const actor = getCurrentActor();
+
+  if (!actor || actor.type !== AgentType.HUMAN) {
+    renderError(isJson, "Only human users can unassign issues.", "FORBIDDEN");
+    return 1;
+  }
+  
+  let issue;
+
+  try {
+    issue = getIssue(issueId);
+  } catch (error) {
+    if (error.message.includes("not found")) {
+      renderError(isJson, error.message, "NOT_FOUND");
+    } else {
+      renderError(isJson, error.message);
+    }
+    return 1;
+  }
+
+  if (!issue.assigneeId) {
+    renderError(
+      isJson,
+      `Issue #${issueId} is not assigned.`,
+      "INVALID_STATE"
+    );
+    return 1;
+  }
+
+  try {
+    // Use unassignIssue from issuesService.js
+    const updatedIssue = unassignIssue(issueId);
+
+    const envelope = {
+      status: "success",
+      issue: serializeIssue(updatedIssue),
+    };
+
+    renderOutput(isJson, envelope, () => {
+      console.log(`Success: Issue #${issueId} is now unassigned.`);
+    });
+
+    return 0;
+  } catch (error) {
+    renderError(isJson, error.message);
+    return 1;
+  }
+}

package/source/commands/update.js

@@ -25,8 +25,9 @@ import { spawnSync } from "child_process";
 import { writeFileSync, readFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
+import { listAgents, getAgentByName } from '../services/agentsService.js';
 
-const ALLOWED_UPDATE_FIELDS = ['title', 'status', 'priority', 'tokenLimit', 'description'];
+const ALLOWED_UPDATE_FIELDS = ['title', 'status', 'priority', 'tokenLimit', 'description', 'assigneeId'];
 
 const VALID_FLAGS = new Set([
   ...ALLOWED_UPDATE_FIELDS.map(key => issueSchema[key].flag),
@@ -161,6 +162,24 @@ async function runInteractiveMode(issue) {
     if (edited !== null) results.description = edited;
   }
 
+  // Assignee
+  const wantsAssignee = await confirm({
+    message: "Edit assignee?",
+    default: false,
+  });
+  if (wantsAssignee) {
+    const agents = listAgents();
+    const assigneeChoices = [
+      { name: '(none)', value: null },
+      ...agents.map(agent => ({ name: `${agent.name} (${agent.type})`, value: agent.id }))
+    ];
+    results.assigneeId = await select({
+      message: 'Assign to:',
+      choices: assigneeChoices,
+      default: issue.assigneeId ?? null
+    });
+  }
+
   // Diff: loop over results and collect only what changed.
   // Adding a new prompt above is all that is needed -- nothing to update here.
   const pending = Object.fromEntries(
@@ -236,6 +255,17 @@ export async function run(args) {
       ? await runInteractiveMode(oldIssue)
       : parseArgs(cmdArgs.slice(1));
 
+    // Getting agent name from ID
+    if (options.assigneeId) {
+      const target = getAgentByName(options.assigneeId);
+      if (!target) {
+        const agents = listAgents();
+        const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+        throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+      }
+      options.assigneeId = target.id;
+    }
+
     const newIssue = await updateIssue(id, oldIssue, options);
     const envelope = { status: "success", issue: serializeIssue(newIssue) };
 

package/source/db/index.js

@@ -18,7 +18,8 @@ if (!fs.existsSync(dataDir)) {
 }
 
 // Initialize better-sqlite3 connection
-const sqliteConnection = new Database(dbPath);
+// Using let here so we can reassign it in tests with an in-memory database instance.
+let sqliteConnection = new Database(dbPath);
 
 // Initialize Drizzle ORM, passing in the schema for relational queries
 // Using let here so we can reassign it in tests with an in-memory database instance.
@@ -71,6 +72,7 @@ export function getSQLiteDB() {
 }
 
 // function for the test suite mocking
-export function setTestDB(testDbInstance) {
+export function setTestDB(testDbInstance, testSqliteConnection) {
   db = testDbInstance;
+  if (testSqliteConnection) sqliteConnection = testSqliteConnection;
 }

package/source/models/activityLog.js

@@ -14,12 +14,14 @@ export class ActivityLog {
     issueId,
     actorId   = null,
     action,
+    details   = null,
     createdAt = new Date().toISOString(),
   } = {}) {
     this.logId     = logId;
     this.issueId   = issueId;
     this.actorId   = actorId;
     this.action    = action;
+    this.details   = details,
     this.createdAt = createdAt;
   }
 }

package/source/models/schema.js

@@ -53,7 +53,7 @@ export const issueSchema = {
     tokenLimit: { flag: '--token-limit', type: 'number' },
     priority:   { flag: '--priority', type: 'enum', values: Object.values(Priority) },
     description:{ flag: '--description', type: 'string' },
-    assigneeId: { flag: '--assignee-id', type: 'number'},
+    assigneeId: { flag: '--assignee', type: 'string'},
     // Pagination options 
     limit:      { flag: '--limit', type: 'number' },
     offset:     { flag: '--offset', type: 'number' }

package/source/services/agentRestrictions.js

@@ -0,0 +1,26 @@
+// agentRestrictions.js 
+
+const AGENT_RESTRICTED_COMMANDS = new Set(['init', 'approve', 'reject', 'delete', 'priority']);
+const AGENT_RESTRICTED_FLAGS = new Set(['--status', '--token-limit', '--assignee']);
+
+/**
+ * Validates whether an actor has permission to execute a given command and arguments.
+ * @param {string} command - The primary CLI command name.
+ * @param {string[]} [args=[]] - The command line arguments.
+ * @throws {Error} If the agent entered a restricted command or flag
+ */
+export function authorizeAction(command, args = []) {
+  if (AGENT_RESTRICTED_COMMANDS.has(command)) {
+    throw new Error(`Command "${command}" is restricted to human users only.`);
+  }
+
+  if (command === 'update') {
+    const usedRestricted = args.filter(arg => AGENT_RESTRICTED_FLAGS.has(arg));
+    if (usedRestricted.length > 0) {
+      throw new Error(
+        `Agents cannot update parameters: ${usedRestricted.join(', ')}. ` +
+        `Use 'baton claim', 'baton submit', or 'baton unclaim' for status changes.`
+      );
+    }
+  }
+}

package/source/services/authService.js

@@ -1,6 +1,8 @@
 import os from 'os';
 import { getAgentByName } from './agentsService.js';
 import { setCurrentActor, getCurrentActor } from './context.js';
+import { isTrackerReady } from './issuesService.js';
+import { authorizeAction } from './agentRestrictions.js';
 
 export { getCurrentActor };
 
@@ -10,30 +12,35 @@ export { getCurrentActor };
  * If the agent/user is registered, it sets them as the active actor for this session.
  * If not, it terminates the process with a helpful error message.
  * @param {string} command - The command being executed
+ * @param {string[]} [args=[]] - The command line arguments.
  */
-export function authenticateContext(command) {
-  const exemptCommands = ['init', 'register', 'help'];
+export function authenticateContext(command, args = []) {
+  const exemptCommands = ['register', 'help'];
   if (exemptCommands.includes(command)) {
     return;
   }
 
-  const activeName = process.env.BATON_AGENT || os.userInfo().username;
-
-  try {
-    const agent = getAgentByName(activeName);
+  if (!isTrackerReady()) {
+    if (command === 'init') {
+      return;
+    }
+    console.error("Error: Tracker is not initialized. Please run 'baton init' first.");
+    process.exit(1);
+  }
 
-    if (!agent) {
+  const activeName = process.env.BATON_AGENT || os.userInfo().username;
+  const agent = getAgentByName(activeName);
+    
+  if (!agent) {
       console.error(`Error: Agent/User "${activeName}" is not registered in this Baton tracker.`);
       console.error(`Please run 'baton register --name "${activeName}" --type "human"' (or "agent") first.`);
       process.exit(1);
-    }
+  }
 
-    setCurrentActor(agent);
-  } catch (error) {
-    if (error.message && error.message.includes('no such table: agents')) {
-      console.error("Error: Tracker is not initialized. Please run 'baton init' first.");
-      process.exit(1);
-    }
-    throw error;
+  // Check if agent entered a restricted command
+  if (agent.type === 'agent') {
+    authorizeAction(command, args);
   }
+
+  setCurrentActor(agent);
 }

package/source/services/issuesService.js

@@ -1,3 +1,4 @@
+// AI was consulted to guide implementation of part of the file.
 import { getDB } from '../db/index.js';
 import { eq, and, or, like, sql } from "drizzle-orm";
 import {issuesTable, activityTable} from "../models/schema.js";
@@ -257,6 +258,24 @@ export function updateIssue(id, oldIssue, { title, description, tokenLimit, stat
   return getIssue(id);
 }
 
+/**
+ * 
+ * Sets assigneeId to null
+ * Logs an edit event
+ * @param {number} issueId - ID of the issue to be editted
+ * @returns {Issue}
+ */
+export function unassignIssue(issueId){
+  const db = getDB();
+
+  // Check that issue exists
+  findById(db, issueId);
+
+  db.update(issuesTable).set({ status: Status.OPEN, assigneeId: null }).where(eq(issuesTable.id, issueId)).run();
+  logActivity(db, issueId, Action.EDIT, `Success: Issue #${issueId} is now unassigned.`);
+  return getIssue(issueId);
+}
+
 /**
  * Change the status of an issue from in-review to closed
  * Logs a closed event.
@@ -384,7 +403,7 @@ export function deleteIssue(id) {
  */
 export function getActivityLog(issueId) {
   const db = getDB();
-  return db.select().from(activityTable).where(eq(activityTable.issueId, issueId)).all();
+  return db.select().from(activityTable).where(eq(activityTable.issueId, issueId)).all().map(rowToLog);
 }
 
 /**
@@ -394,7 +413,7 @@ export function getActivityLog(issueId) {
  */
 export function getRecentActivity({ limit = 20 } = {}) {
   const db = getDB();
-  return db.select().from(activityTable).orderBy(sql`${activityTable.logId} DESC`).limit(limit).all();
+  return db.select().from(activityTable).orderBy(sql`${activityTable.logId} DESC`).limit(limit).all().map(rowToLog);
 }
 // =============================================================================
 // Tracker operations (CLI: init / next / status / claim)

package/source/util.js

@@ -5,6 +5,7 @@
 
 import { isAbsolute, resolve } from 'node:path';
 import { issueSchema } from '../source/models/schema.js';
+import { getAgentById } from '../source/services/agentsService.js';
 
 /**
  * Formats a timestamp as `HH:MM:SS YYYY-MM-DD`.
@@ -269,7 +270,7 @@ export const WIDTHS = {
   title: 20,
   status: 15,
   priority: 10,
-  //assignees: 10, 
+  assignee: 10, 
   description: 50
 };
 
@@ -283,7 +284,7 @@ export function printTableHeader() {
     "TITLE".padEnd(WIDTHS.title) + " │ " +
     "STATUS".padEnd(WIDTHS.status) + " │ " +
     "PRIORITY".padEnd(WIDTHS.priority) + " │ " +
-    //"ASSIGNEE".padEnd(WIDTHS.assignees) + " │ " +
+    "ASSIGNEE".padEnd(WIDTHS.assignee) + " │ " +
     "DESCRIPTION".padEnd(WIDTHS.description)
   );
   console.log(
@@ -291,7 +292,7 @@ export function printTableHeader() {
     "─".repeat(WIDTHS.title) + "─┼─" +
     "─".repeat(WIDTHS.status) + "─┼─" +
     "─".repeat(WIDTHS.priority) + "─┼─" +
-    //"─".repeat(WIDTHS.assignees) + "─┼─" +
+    "─".repeat(WIDTHS.assignee) + "─┼─" +
     "─".repeat(WIDTHS.description)
   );
 }
@@ -324,9 +325,10 @@ export function printIssueTable(issue) {
   const priorityVal = truncate(issue.priority, WIDTHS.priority).padEnd(WIDTHS.priority);
   const descVal = truncate(issue.description, WIDTHS.description).padEnd(WIDTHS.description);
 
-  // Handling the assignee array
-  //const assigneesVal = Array.isArray(issue.assignees) ? issue.assignees.join(', ') : 'None';
-  //const assigneeVal = truncate(assigneesVal, WIDTHS.assignees).padEnd(WIDTHS.assignees);
+  // Getting Agent name from id
+  const assigneeId = issue.assigneeId ?? issue.assignee_id ?? null;
+  const assignee = assigneeId ? getAgentById(assigneeId) : null;
+  const assigneeVal = truncate(assignee?.name ?? null, WIDTHS.assignee).padEnd(WIDTHS.assignee);
 
-  console.log(`${idVal} │ ${titleVal} │ ${statusVal} │ ${priorityVal} │ ${descVal}`);
+  console.log(`${idVal} │ ${titleVal} │ ${statusVal} │ ${priorityVal} │ ${assigneeVal} │ ${descVal}`);
 }