@ivanbard/dd2l 0.1.0 → 0.1.1

package/src/task-workspace.mjs

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+import { matches } from '../ui/answer-view.js';
+import { researchActions } from './research.mjs';
+
+const text = maxLength => ({ type: 'string', maxLength });
+const object = properties => ({ type: 'object', properties, required: Object.keys(properties), additionalProperties: false });
+const list = (items, maxItems, minItems = 0) => ({ type: 'array', items, minItems, maxItems });
+export const workspacePlanSchema = object({
+  title: text(160), goal: text(1000), question: text(500),
+  sections: list(object({ title: text(160), purpose: text(500), sourceIds: list(text(80), 24, 1) }), 8),
+});
+
+const fail = message => Object.assign(new Error(message), { public: true });
+const excerpt = (value, length) => value.length > length ? `${value.slice(0, length)}\n[Excerpt truncated.]` : value;
+
+export function taskCatalogue(inventory, course = '') {
+  const allowed = new Set(inventory.courses.filter(item => !course || item.id === course).map(item => item.id));
+  const parents = new Set((inventory.assignments || []).map(assignment => `${assignment.course}:${assignment.id}`));
+  const sources = inventory.sources.filter(source => {
+    const assignment = source.id.match(/\/dropbox\/folders\/(\d+)(?:\/|#|$)/)?.[1] ||
+      (source.category === 'rubrics' ? source.id.match(/[?&]objectId=(\d+)(?:&|#|$)/)?.[1] : null);
+    return allowed.has(source.course) && (!assignment || parents.has(`${source.course}:${assignment}`));
+  }).map(source => ({ ...source,
+    ref: JSON.stringify([source.course, source.category, source.id, source.title]),
+  }));
+  for (const assignment of inventory.assignments || []) {
+    if (!allowed.has(assignment.course)) continue;
+    const parent = `${assignment.course}:${assignment.id}`;
+    sources.push({ ...assignment, category: 'assignment', ref: `${parent}:overview`,
+      text: `Due: ${assignment.dueDate || 'Not retrieved'}\nOpens: ${assignment.startDate || 'Not retrieved'}\nCloses: ${assignment.endDate || 'Not retrieved'}\n${assignment.submissionStatus}`,
+      records: undefined, parent });
+    for (const record of assignment.records) sources.push({ ...record, title: `${assignment.title} · ${record.title}`,
+      text: record.text || `${record.title}: ${record.status}. No readable text retrieved.`, ref: record.id, parent });
+  }
+  return sources.map(({ ref, records, ...source }) => ({ ...source,
+    id: createHash('sha256').update(ref).digest('base64url').slice(0, 24),
+  }));
+}
+
+// Bounded catalogue selection is distinct from evidence selection: the model sees varied records,
+// including records with no literal query overlap, and can follow assignment relationships.
+export function planningCatalogue(sources, query, context = null, preferred = []) {
+  const terms = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) || [])];
+  const previous = new Set(context?.sourceIds || []);
+  const ranked = sources.map((source, index) => ({ source, index,
+    score: (previous.has(source.id) ? 10 : 0) + terms.reduce((score, term) => score +
+      (source.title.toLowerCase().includes(term) ? 3 : source.text.toLowerCase().includes(term) ? 1 : 0), 0),
+  })).sort((a, b) => {
+    const left = preferred.indexOf(a.source.id), right = preferred.indexOf(b.source.id);
+    return (left < 0 ? Infinity : left) - (right < 0 ? Infinity : right) || b.score - a.score || a.index - b.index;
+  });
+  const selected = new Map(ranked.slice(0, 200).map(({ source }) => [source.id, source]));
+  // Reserve space for every course/category rather than letting a large course crowd out others.
+  const buckets = new Map();
+  for (const source of sources) {
+    const key = `${source.course}:${source.category}`;
+    if (!buckets.has(key)) buckets.set(key, []);
+    buckets.get(key).push(source);
+  }
+  for (let round = 0; selected.size < 400; round++) {
+    let added = false;
+    for (const bucket of buckets.values()) {
+      if (selected.size >= 400) break;
+      const source = bucket[round];
+      if (source && !selected.has(source.id)) { selected.set(source.id, source); added = true; }
+    }
+    if (!added && [...buckets.values()].every(bucket => round >= bucket.length)) break;
+  }
+  return [...selected.values()].map(source => ({ id: source.id, course: source.courseName, category: source.category,
+    title: excerpt(source.title, 200), preview: excerpt(source.text, 400), parent: source.parent || null,
+    dueDate: source.dueDate || null, stale: !!source.stale, status: source.status || 'available',
+  }));
+}
+
+export function buildTaskWorkspace(plan, sources, catalogueCount, total) {
+  const byId = new Map(sources.map(source => [source.id, source]));
+  if (!matches(plan, workspacePlanSchema) || !plan.title.trim() || !plan.goal.trim() || plan.sections.some(section => !section.sourceIds.length ||
+    section.sourceIds.some(id => !byId.has(id)))) throw fail('The workspace plan could not be verified. Please retry.');
+  const ids = [...new Set(plan.sections.flatMap(section => section.sourceIds))];
+  if (ids.length > 24 || (!ids.length && !plan.question.trim())) throw fail('The workspace plan needs sources or a clarifying question. Please retry.');
+  const evidence = ids.map(id => {
+    const { text, ...source } = byId.get(id);
+    return { ...source, excerpt: excerpt(text, 8000) };
+  });
+  return { workspace: { kind: 'task', title: plan.title, goal: plan.goal, question: plan.question,
+    sections: plan.sections.map(section => ({ ...section, sources: section.sourceIds.map(id => {
+      const source = byId.get(id);
+      return { id, title: source.title, category: source.category, courseName: source.courseName,
+        text: excerpt(source.text, 30_000), url: source.url, dueDate: source.dueDate || null,
+        stale: !!source.stale, status: source.status || 'available', lastSuccess: source.lastSuccess || null };
+    }) })),
+    context: { goal: plan.goal, sourceIds: ids }, catalogueCount, total }, sources: evidence };
+}
+
+export function validTaskContext(context) {
+  if (context === null) return true;
+  if (!context || typeof context !== 'object' || Array.isArray(context)) return false;
+  const { summary, ...references } = context;
+  return matches(references, object({ goal: text(1000), sourceIds: list(text(80), 24) })) &&
+    (summary === undefined || (typeof summary === 'string' && summary.length <= 12_000));
+}
+
+export async function composeTaskWorkspace(llm, inventory, query, model, course, context, signal, refresh = () => inventory, research = null) {
+  let accountScope = inventory.scope;
+  const checkedInventory = value => {
+    if (accountScope && value.scope !== accountScope) throw fail('School account changed or its cache was cleared. Start a new request.');
+    accountScope ||= value.scope;
+    return value;
+  };
+  for (let round = 0; round <= 4; round++) {
+    signal?.throwIfAborted();
+    const current = checkedInventory(round ? refresh() : inventory);
+    const all = taskCatalogue(current, course);
+    const preferred = research ? all.filter(source => research.keys.has(source.resourceKey))
+      .sort((a, b) => Number(!a.category.includes('file')) - Number(!b.category.includes('file')) || (Date.parse(b.lastSuccess) || 0) - (Date.parse(a.lastSuccess) || 0)).map(source => source.id) : [];
+    const catalogue = planningCatalogue(all, query, context, preferred);
+    const plan = await llm.planWorkspace(query, model, { catalogue, total: all.length,
+      courses: current.courses.filter(item => !course || item.id === course), now: new Date().toISOString(),
+      ...(research ? { browsing: { available: round < 4 && research.available, remaining: round < 4 ? research.remaining : 0, history: research.history } } : {}),
+    }, context, signal);
+    if (plan.requests?.length) {
+      if (!matches(plan.requests, researchActions)) throw fail('The model returned invalid Brightspace read requests.');
+      if (!research || round === 4 || !research.available) throw fail('The model exceeded the live reading budget. Please narrow your request.');
+      if (plan.sections?.length) throw fail('The model must finish reading before selecting workspace sources.');
+      for (const action of plan.requests) {
+        if (!research.available) break;
+        await research.execute(action);
+      }
+      continue;
+    }
+    const { requests, ...finalPlan } = plan;
+    const visible = new Set(catalogue.map(source => source.id));
+    const task = buildTaskWorkspace(finalPlan, taskCatalogue(checkedInventory(refresh()), course).filter(source => visible.has(source.id)), catalogue.length, all.length);
+    if (research?.history.length) task.workspace.research = research.history.map(({ action, result }) => ({ action: action.action,
+      section: action.section || 'resource', outcome: result.outcome, message: result.message || '', outcomes: result.outcomes || [] }));
+    return task;
+  }
+}

package/src/ui-data.mjs

@@ -1,12 +1,17 @@
 import { DatabaseSync } from 'node:sqlite';
 import { htmlContent } from './documents.mjs';
-import { SCHOOL } from './client.mjs';
+import { SCHOOL, schoolOrigin } from './client.mjs';
 import { createHash } from 'node:crypto';
+import { projectAssignments } from './assignment-workspace.mjs';
 
 const categories = new Set(['content', 'overview', 'syllabus_source', 'assignments', 'quizzes', 'announcements',
-  'calendar', 'calendar_occurrences', 'content_file', 'assignment_file', 'linked_content', 'video_transcript']);
+  'calendar', 'calendar_occurrences', 'content_file', 'assignment_file', 'linked_content', 'video_transcript',
+  'quiz_details', 'own_quiz_attempts', 'grades', 'own_feedback', 'feedback_file', 'rubrics',
+  'discussion_forums', 'discussion_topics', 'discussion_posts', 'discussion_file']);
 const textFields = new Set(['Title', 'Name', 'Subject', 'Text', 'Html', 'text', 'Description', 'Instructions',
-  'Body', 'Content', 'StartDate', 'EndDate', 'DueDate', 'StartDateTime', 'EndDateTime']);
+  'Body', 'Content', 'StartDate', 'EndDate', 'DueDate', 'StartDateTime', 'EndDateTime',
+  'DisplayedGrade', 'PointsNumerator', 'PointsDenominator', 'WeightedNumerator', 'WeightedDenominator',
+  'Feedback', 'FeedbackText', 'Score', 'Points', 'MaxPoints', 'CompletionDate', 'TimeLimit']);
 
 // Open for each request so logout, revoked access and new syncs are reflected immediately.
 export function readInventory(path) {
@@ -20,9 +25,10 @@ export function readInventory(path) {
     };
     const state = meta('state');
     const rows = db.prepare(`SELECT key,course,category,data,last_success,checked_at,outcome
-      FROM resources WHERE data IS NOT NULL AND outcome NOT IN ('denied','not_configured')`).all()
+      FROM resources`).all()
       .map(row => ({ ...row, data: JSON.parse(row.data) }));
-    return { ...projectInventory(rows, state), scope: createHash('sha256').update(String(meta('account') || 'local')).digest('hex') };
+    const account = meta('account');
+    return { ...projectInventory(rows, state, meta('school_origin') ?? SCHOOL), scope: account ? createHash('sha256').update(account).digest('hex') : null };
   } catch (error) {
     if (error.code === 'ERR_SQLITE_ERROR' && /unable to open database/.test(error.message)) {
       return { courses: [], sources: [], state: null };
@@ -31,44 +37,60 @@ export function readInventory(path) {
   } finally { db?.close(); }
 }
 
-export function projectInventory(rows, state) {
+export function projectInventory(rows, state, origin = SCHOOL) {
+  origin = schoolOrigin(origin);
   const enrollment = rows.find(row => row.category === 'enrollments' && !['denied', 'not_configured'].includes(row.outcome));
   const courses = (enrollment?.data ?? []).filter(item => item.Access?.CanAccess === true && item.OrgUnit?.Id)
     .map(item => ({ id: String(item.OrgUnit.Id), name: item.OrgUnit.Name || `Course ${item.OrgUnit.Id}`,
       active: item.Access.IsActive === true }));
   const allowed = new Map(courses.map(course => [course.id, course]));
+  const assignments = projectAssignments(rows, courses, origin);
+  const assignmentParents = new Set(assignments.map(item => `${item.course}:${item.id}`));
+  const restrictedQuizzes = rows.filter(row => row.category === 'quiz_details' &&
+    (['denied', 'not_configured'].includes(row.outcome) || row.data?.IsHidden || row.data?.IsLocked || row.data?.IsPublished === false));
   const sources = [];
   for (const row of rows) {
     if (!categories.has(row.category) || !allowed.has(String(row.course)) || ['denied', 'not_configured'].includes(row.outcome)) continue;
-    const visit = (value, parentTitle = '', depth = 0) => {
+    const assignment = row.key?.match(/\/dropbox\/folders\/(\d+)(?:\/|$)/)?.[1] ||
+      (row.category === 'rubrics' ? row.key?.match(/[?&]objectId=(\d+)(?:&|$)/)?.[1] : null);
+    if (assignment && !assignmentParents.has(`${row.course}:${assignment}`)) continue;
+    if (restrictedQuizzes.some(quiz => String(quiz.course) === String(row.course) && row.key?.startsWith(`${quiz.key}/`))) continue;
+    const visit = (value, parentTitle = '', depth = 0, path = '$') => {
       if (!value || typeof value !== 'object' || depth > 15) return;
-      if (Array.isArray(value)) { for (const item of value) visit(item, parentTitle, depth + 1); return; }
+      if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+          const id = item?.TopicId ?? item?.Id ?? item?.NewsId ?? item?.GradeObjectIdentifier;
+          visit(item, parentTitle, depth + 1, `${path}/${/^\d+$/.test(String(id)) ? `id${id}` : index}`);
+        }
+        return;
+      }
       if (value.IsHidden || value.IsLocked || value.IsDeleted || value.IsPublished === false ||
         Date.parse(value.StartDateTime) > Date.now() || Date.parse(value.EndDateTime) < Date.now() ||
         (row.category === 'announcements' && (Date.parse(value.StartDate) > Date.now() || Date.parse(value.EndDate) < Date.now()))) return;
       const title = String(value.Title || value.Name || value.Subject || value.title || parentTitle || row.category.replaceAll('_', ' '));
       const parts = [];
       const collect = (item, field, level = 0) => {
-        if (typeof item === 'string') parts.push(['Html', 'Description', 'Instructions', 'Body', 'Content'].includes(field) ? htmlContent(item).text : item);
+        if (typeof item === 'number') parts.push(`${field}: ${item}`);
+        else if (typeof item === 'string') parts.push(['Html', 'Description', 'Instructions', 'Body', 'Content'].includes(field) ? htmlContent(item).text : item);
         else if (item && typeof item === 'object' && !Array.isArray(item) && level < 3) {
           for (const [key, child] of Object.entries(item)) if (textFields.has(key)) collect(child, key, level + 1);
         }
       };
       for (const [key, child] of Object.entries(value)) if (textFields.has(key)) collect(child, key);
       const text = [...new Set(parts.filter(Boolean))].join('\n').slice(0, 1_000_000);
-      if (text) sources.push({ id: `${row.key}#${sources.length}`, course: String(row.course),
+      if (text) sources.push({ id: `${row.key}#${path}`, resourceKey: row.key, course: String(row.course),
         courseName: allowed.get(String(row.course)).name, title, text, category: row.category,
         lastSuccess: row.last_success, checkedAt: row.checked_at, stale: row.outcome !== 'available',
-        dueDate: ['assignments', 'quizzes', 'calendar', 'calendar_occurrences'].includes(row.category) && Number.isFinite(Date.parse(value.DueDate)) ? value.DueDate : null,
+        dueDate: ['assignments', 'quizzes', 'quiz_details', 'calendar', 'calendar_occurrences'].includes(row.category) && Number.isFinite(Date.parse(value.DueDate)) ? value.DueDate : null,
         publishedAt: row.category === 'announcements' ? value.PublishedDate || value.StartDate || null : null,
-        url: `${SCHOOL}/d2l/home/${row.course}` });
+        url: `${origin}/d2l/home/${row.course}` });
       for (const [key, child] of Object.entries(value)) {
-        if (!textFields.has(key) && child && typeof child === 'object') visit(child, title, depth + 1);
+        if (!textFields.has(key) && child && typeof child === 'object') visit(child, title, depth + 1, `${path}/${key}`);
       }
     };
     visit(row.data);
   }
-  return { courses, sources, state };
+  return { courses, sources, assignments, state };
 }
 
 export function homeInventory(inventory, now = Date.now()) {

package/src/ui-demo.mjs

@@ -7,14 +7,30 @@ export function demoInventory() {
   return { ...projectInventory([
     row('enrollments', null, [
       { OrgUnit: { Id: 101, Name: 'CISC 121 · Introduction to Computing' }, Access: { CanAccess: true, IsActive: true } },
+      { OrgUnit: { Id: 103, Name: 'ELEC 425 · Signals and Systems' }, Access: { CanAccess: true, IsActive: true } },
       { OrgUnit: { Id: 102, Name: 'PSYC 100 · Principles of Psychology' }, Access: { CanAccess: true, IsActive: true } },
     ]),
-    row('assignments', '101', [{ Name: 'Assignment 3 · Recursion', DueDate: '2026-11-09T23:59:00-05:00',
+    row('assignments', '101', [{ Id: 201, Name: 'Assignment 3 · Recursion', DueDate: '2026-11-09T23:59:00-05:00',
       Instructions: { Text: 'Implement and test recursive functions. Submit your Python file and a short explanation through onQ. Review the recursion lecture before starting.' } }]),
     row('syllabus_source', '101', { title: 'Course syllabus', text: 'Assessment: assignments 30%, labs 20%, final exam 50%. Office hours are Tuesday, 2–4 pm. Consult onQ for the current schedule.' }),
     row('content', '102', { Modules: [{ Title: 'Week 8 · Memory', Topics: [
       { Title: 'Memory and retrieval', Description: { Text: 'Encoding, working memory, long-term memory, and retrieval practice. Read chapter 8 before the seminar.' } },
     ] }] }),
     row('announcements', '102', [{ Title: 'Midterm review session', Body: { Text: 'Bring your questions about memory and learning to the review session on Thursday.' } }]),
+    row('assignments', '102', [{ Id: 203, Name: 'Assignment 2 · Memory journal', DueDate: '2026-11-13T23:59:00-05:00',
+      Instructions: { Text: 'Write a reflection on retrieval practice and your study habits.' } }]),
+    row('assignments', '103', [{ Id: 202, Name: 'Assignment 2 · Filter design', DueDate: '2026-11-12T23:59:00-05:00',
+      Instructions: { Text: 'Design a low-pass filter. Submit a PDF report with your calculations, frequency response plots, and MATLAB code. Review Frequency response before starting.' },
+      Attachments: [{ FileId: 7, FileName: 'Filter specifications.pdf' }] }]),
+    { ...row('rubrics', '103', [{ Name: 'Filter design rubric', Criteria: [
+      { Name: 'Design and calculations', Points: 40, Description: { Text: 'Justify the filter parameters and show your calculations.' } },
+      { Name: 'Validation', Points: 40, Description: { Text: 'Include labelled frequency response plots and discuss the results.' } },
+      { Name: 'Presentation', Points: 20, Description: { Text: 'Use a readable report with reproducible MATLAB code.' } },
+    ] }]), key: '/d2l/api/le/1.93/103/rubrics/?objectType=Dropbox&objectId=202' },
+    { ...row('assignment_file', '103', { text: 'Use a 1 kHz cutoff frequency and a 10 kHz sampling rate. Include the magnitude and phase response.' }),
+      key: '/d2l/api/le/1.93/103/dropbox/folders/202/attachments/7' },
+    { ...row('own_submissions', '103', []), key: '/d2l/api/le/1.93/103/dropbox/folders/202/submissions/mysubmissions/' },
+    row('content', '103', { Title: 'Frequency response', Description: { Text: 'Calculate and plot magnitude and phase. Compare the response against the filter specifications.' } }),
+    row('announcements', '103', [{ Title: 'Assignment 2 clarification', Body: { Text: 'For Assignment 2, include both magnitude and phase plots in your report.' } }]),
   ], { state: 'demo', updatedAt: stamp }), scope: 'demo' };
 }

package/src/ui-server.mjs

@@ -6,6 +6,11 @@ import { parseArgs } from 'node:util';
 import { readInventory, searchInventory, homeInventory } from './ui-data.mjs';
 import { demoInventory } from './ui-demo.mjs';
 import { ChatGPT } from './llm.mjs';
+import { assignmentWorkspace } from './assignment-workspace.mjs';
+import { composeTaskWorkspace, validTaskContext, taskCatalogue } from './task-workspace.mjs';
+import { validCanvasContext, validCanvas } from '../ui/canvas-contract.js';
+import { canvasDocument } from './canvas.mjs';
+import { createResearch } from './research.mjs';
 
 const root = fileURLToPath(new URL('../ui/', import.meta.url));
 const mime = { '.html': 'text/html; charset=utf-8', '.css': 'text/css', '.js': 'text/javascript', '.svg': 'image/svg+xml', '.png': 'image/png' };
@@ -28,14 +33,14 @@ ${connected ? '<a class="auth-usage" href="https://chatgpt.com/settings/usage" t
 </main></body></html>`;
 }
 
-export function createUiServer({ demo = false, inventoryPath = join(process.env.LOCALAPPDATA || '', 'dd2l', 'inventory.sqlite'),
+export function createUiServer({ demo = false, connector, shutdownSignal, inventoryPath = connector?.store.path || join(process.env.LOCALAPPDATA || '', 'dd2l', 'inventory.sqlite'),
   llm = demo ? null : new ChatGPT(join(process.env.LOCALAPPDATA || '', 'dd2l')) } = {}) {
   return createServer(async (req, res) => {
     const authority = `127.0.0.1:${res.socket.localPort}`;
-    const send = (status, body, type = 'application/json') => {
+    const send = (status, body, type = 'application/json', policy) => {
       res.writeHead(status, { 'Content-Type': type, 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff',
-        'Referrer-Policy': 'no-referrer', 'Cross-Origin-Resource-Policy': 'same-origin', 'X-Frame-Options': 'DENY',
-        'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'" });
+        'Referrer-Policy': 'no-referrer', 'Cross-Origin-Resource-Policy': 'same-origin', 'X-Frame-Options': policy ? 'SAMEORIGIN' : 'DENY',
+        'Content-Security-Policy': policy || "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'" });
       res.end(type === 'application/json' ? JSON.stringify(body) : body);
     };
     const callback = req.method === 'GET' && req.url.startsWith('/auth/callback?');
@@ -62,7 +67,7 @@ export function createUiServer({ demo = false, inventoryPath = join(process.env.
         let bytes = 0;
         for await (const chunk of req) {
           bytes += chunk.length;
-          if (bytes > 8192) { send(413, { error: 'Request too large.' }); return; }
+          if (bytes > (url.pathname === '/api/llm/answer' ? 1_000_000 : 8192)) { send(413, { error: 'Request too large.' }); return; }
           chunks.push(chunk);
         }
         let data;
@@ -73,39 +78,69 @@ export function createUiServer({ demo = false, inventoryPath = join(process.env.
         else if (url.pathname === '/api/llm/select') send(200, await llm.select(data.id));
         else if (url.pathname === '/api/llm/logout') send(200, await llm.logout());
         else if (url.pathname === '/api/llm/answer') {
-          const { q, course = '', model, consent } = data;
+          const { q, course = '', assignment = '', context = null, canvas = null, model, consent } = data;
           if (typeof q !== 'string' || !q.trim() || q.length > 500 || typeof course !== 'string' || (course && !/^\d+$/.test(course)) || typeof model !== 'string' || !model || model.length > 200 || consent !== true) {
-            send(400, { error: 'Provide a question, course, model and permission to send excerpts to OpenAI.' }); return;
+            send(400, { error: 'Provide a question, course, model and permission to share coursework and workspace progress with OpenAI.' }); return;
           }
+          if (typeof assignment !== 'string' || (assignment && (!/^\d+$/.test(assignment) || !course))) { send(400, { error: 'Invalid assignment context.' }); return; }
+          if (!validTaskContext(context)) { send(400, { error: 'Invalid workspace context.' }); return; }
+          if (!validCanvasContext(canvas)) { send(400, { error: 'Invalid canvas state.' }); return; }
           const inventory = readInventory(inventoryPath);
           if (course && !inventory.courses.some(c => c.id === course)) { send(404, { error: 'Course is not available in this inventory.' }); return; }
-          const sources = searchInventory(inventory, q, course).results.slice(0, 8);
           const controller = new AbortController();
           const abort = () => controller.abort();
           res.on('close', abort);
-          try { send(200, { ...await llm.answer(q, model, sources, AbortSignal.any([controller.signal, AbortSignal.timeout(90_000)])), sources }); }
+          try {
+            const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(300_000), ...(shutdownSignal ? [shutdownSignal] : [])]);
+            const research = createResearch({ connector, inventoryPath, scope: course, accountScope: inventory.scope || '', signal });
+            const task = await composeTaskWorkspace(llm, inventory, q, model, course, context, signal,
+              () => readInventory(inventoryPath), research);
+            if (task.workspace.question) { send(200, task); return; }
+            try {
+              const generated = await llm.generateCanvas(`Goal: ${task.workspace.goal}\nCurrent request: ${q}`, model, task.sources, canvas, signal);
+              if (!validCanvas(generated)) throw new Error('Invalid generated canvas');
+              send(200, { canvas: generated, answer: generated.answer, ...task });
+            } catch (error) {
+              if (controller.signal.aborted) throw error;
+              send(200, { ...task, answerWarning: error.public ? error.message : 'AI explanation is unavailable. Your selected sources are available below.' });
+            }
+          }
           finally { res.off('close', abort); }
         } else send(404, { error: 'Not found.' });
         return;
       }
       if (req.method !== 'GET') { send(405, { error: 'This route is read-only.' }); return; }
       if (url.pathname.startsWith('/api/')) {
-        if (!['/api/status', '/api/courses', '/api/search', '/api/home'].includes(url.pathname)) { send(404, { error: 'Not found.' }); return; }
+        if (!['/api/status', '/api/courses', '/api/search', '/api/home', '/api/source'].includes(url.pathname)) { send(404, { error: 'Not found.' }); return; }
         const query = url.searchParams.get('q') || '';
         const course = url.searchParams.get('course') || '';
+        const assignment = url.searchParams.get('assignment') || '';
+        if (assignment && (!/^\d+$/.test(assignment) || !course)) { send(400, { error: 'Invalid assignment context.' }); return; }
         if (query.length > 500 || (course && !/^\d+$/.test(course))) { send(400, { error: 'Use a query of at most 500 characters and a valid course.' }); return; }
         const inventory = demo ? demoInventory() : readInventory(inventoryPath);
         if (course && !inventory.courses.some(item => item.id === course)) { send(404, { error: 'Course is not available in this inventory.' }); return; }
-        if (url.pathname === '/api/status') send(200, { demo, state: inventory.state,
+        if (url.pathname === '/api/source') {
+          const id = url.searchParams.get('id') || '';
+          if (!/^[\w-]{24}$/.test(id)) { send(400, { error: 'Invalid source reference.' }); return; }
+          const source = taskCatalogue(inventory, course).find(source => source.id === id);
+          if (!source) { send(404, { error: 'This source is no longer available. Refresh the workspace.' }); return; }
+          send(200, { id: source.id, title: source.title, courseName: source.courseName, text: source.text.slice(0, 100_000),
+            url: source.url, stale: !!source.stale, lastSuccess: source.lastSuccess || null });
+        }
+        else if (url.pathname === '/api/status') send(200, { demo, state: inventory.state,
           courseCount: inventory.courses.length, sourceCount: inventory.sources.length,
           lastSuccess: inventory.sources.map(source => source.lastSuccess).filter(Boolean).sort().at(-1) || null });
         else if (url.pathname === '/api/home') send(200, { ...homeInventory(inventory), demo });
         else if (url.pathname === '/api/courses') send(200, { courses: inventory.courses });
-        else send(200, { ...searchInventory(inventory, query, course), demo });
+        else send(200, { ...searchInventory(inventory, query, course), workspace: query ? assignmentWorkspace(inventory, query, course, assignment) : null, demo });
         return;
       }
+      if (url.pathname === '/canvas-frame') {
+        const frame = canvasDocument();
+        send(200, frame.html, 'text/html; charset=utf-8', frame.policy); return;
+      }
       const path = url.pathname === '/' ? 'index.html' : url.pathname.slice(1);
-      if (!/^(?:index\.html|app\.js|widgets\.js|widget-layout\.js|answer-view\.js|answer-renderer\.js|loading\.js|style\.css|assets\/[a-z-]+\.(?:svg|png))$/.test(path)) { send(404, { error: 'Not found.' }); return; }
+      if (!/^(?:index\.html|app\.js|canvas\.js|canvas-contract\.js|widgets\.js|widget-layout\.js|assignment-workspace\.js|answer-view\.js|answer-renderer\.js|loading\.js|style\.css|assets\/[a-z-]+\.(?:svg|png))$/.test(path)) { send(404, { error: 'Not found.' }); return; }
       send(200, await readFile(join(root, path)), mime[extname(path)]);
     } catch (error) {
       send(error.code === 'ENOENT' ? 404 : 503, { error: error.public ? error.message : error.code === 'ENOENT' ? 'Not found.' : 'Local data or AI service is unavailable. Retry after the current operation finishes.' });
@@ -118,8 +153,9 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   const port = Number(values.port);
   if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Port must be between 1024 and 65535.');
   if (!values.demo && !process.env.LOCALAPPDATA) throw new Error('Live inventory requires Windows LOCALAPPDATA. Use --demo for sample data.');
-  const server = createUiServer({ demo: values.demo });
+  const controller = new AbortController();
+  const server = createUiServer({ demo: values.demo, shutdownSignal: controller.signal });
   server.on('error', error => { console.error(`Could not start UI: ${error.code}`); process.exitCode = 1; });
   server.listen(port, '127.0.0.1', () => console.log(`dd2l ${values.demo ? 'DEMO (sample data)' : '(local cached coursework)'}: http://127.0.0.1:${port}`));
-  for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => server.close());
+  for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => { controller.abort(); server.close(); server.closeAllConnections(); });
 }

package/src/windows-ocr.ps1

@@ -1,32 +1,32 @@
-param([Parameter(Mandatory=$true)][string]$ImagePath)
-$ErrorActionPreference = 'Stop'
-try {
-  Add-Type -AssemblyName System.Runtime.WindowsRuntime
-  $null = [Windows.Storage.StorageFile, Windows.Storage, ContentType=WindowsRuntime]
-  $null = [Windows.Graphics.Imaging.BitmapDecoder, Windows.Graphics.Imaging, ContentType=WindowsRuntime]
-  $null = [Windows.Media.Ocr.OcrEngine, Windows.Foundation, ContentType=WindowsRuntime]
-  $asTask = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.IsGenericMethod -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' } | Select-Object -First 1
-  function Await-Result($operation, $resultType) {
-    $task = $asTask.MakeGenericMethod($resultType).Invoke($null, @($operation))
-    $task.Wait()
-    $task.Result
-  }
-  $file = Await-Result ([Windows.Storage.StorageFile]::GetFileFromPathAsync($ImagePath)) ([Windows.Storage.StorageFile])
-  $stream = Await-Result ($file.OpenAsync([Windows.Storage.FileAccessMode]::Read)) ([Windows.Storage.Streams.IRandomAccessStream])
-  try {
-    $decoder = Await-Result ([Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream)) ([Windows.Graphics.Imaging.BitmapDecoder])
-    if ([double]$decoder.PixelWidth * $decoder.PixelHeight -gt 16000000) { throw 'Image pixel limit exceeded' }
-    $maximum = [Windows.Media.Ocr.OcrEngine]::MaxImageDimension
-    $scale = [Math]::Min(1.0, $maximum / [double][Math]::Max($decoder.PixelWidth, $decoder.PixelHeight))
-    $transform = [Windows.Graphics.Imaging.BitmapTransform]::new()
-    $transform.ScaledWidth = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelWidth * $scale))
-    $transform.ScaledHeight = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelHeight * $scale))
-    $bitmap = Await-Result ($decoder.GetSoftwareBitmapAsync([Windows.Graphics.Imaging.BitmapPixelFormat]::Bgra8, [Windows.Graphics.Imaging.BitmapAlphaMode]::Ignore, $transform, [Windows.Graphics.Imaging.ExifOrientationMode]::RespectExifOrientation, [Windows.Graphics.Imaging.ColorManagementMode]::DoNotColorManage)) ([Windows.Graphics.Imaging.SoftwareBitmap])
-    try {
-      $engine = [Windows.Media.Ocr.OcrEngine]::TryCreateFromUserProfileLanguages()
-      if ($null -eq $engine) { throw 'OCR language unavailable' }
-      $result = Await-Result ($engine.RecognizeAsync($bitmap)) ([Windows.Media.Ocr.OcrResult])
-      [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($result.Text)))
-    } finally { $bitmap.Dispose() }
-  } finally { $stream.Dispose() }
-} catch { exit 1 }
+param([Parameter(Mandatory=$true)][string]$ImagePath)
+$ErrorActionPreference = 'Stop'
+try {
+  Add-Type -AssemblyName System.Runtime.WindowsRuntime
+  $null = [Windows.Storage.StorageFile, Windows.Storage, ContentType=WindowsRuntime]
+  $null = [Windows.Graphics.Imaging.BitmapDecoder, Windows.Graphics.Imaging, ContentType=WindowsRuntime]
+  $null = [Windows.Media.Ocr.OcrEngine, Windows.Foundation, ContentType=WindowsRuntime]
+  $asTask = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.IsGenericMethod -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' } | Select-Object -First 1
+  function Await-Result($operation, $resultType) {
+    $task = $asTask.MakeGenericMethod($resultType).Invoke($null, @($operation))
+    $task.Wait()
+    $task.Result
+  }
+  $file = Await-Result ([Windows.Storage.StorageFile]::GetFileFromPathAsync($ImagePath)) ([Windows.Storage.StorageFile])
+  $stream = Await-Result ($file.OpenAsync([Windows.Storage.FileAccessMode]::Read)) ([Windows.Storage.Streams.IRandomAccessStream])
+  try {
+    $decoder = Await-Result ([Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream)) ([Windows.Graphics.Imaging.BitmapDecoder])
+    if ([double]$decoder.PixelWidth * $decoder.PixelHeight -gt 16000000) { throw 'Image pixel limit exceeded' }
+    $maximum = [Windows.Media.Ocr.OcrEngine]::MaxImageDimension
+    $scale = [Math]::Min(1.0, $maximum / [double][Math]::Max($decoder.PixelWidth, $decoder.PixelHeight))
+    $transform = [Windows.Graphics.Imaging.BitmapTransform]::new()
+    $transform.ScaledWidth = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelWidth * $scale))
+    $transform.ScaledHeight = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelHeight * $scale))
+    $bitmap = Await-Result ($decoder.GetSoftwareBitmapAsync([Windows.Graphics.Imaging.BitmapPixelFormat]::Bgra8, [Windows.Graphics.Imaging.BitmapAlphaMode]::Ignore, $transform, [Windows.Graphics.Imaging.ExifOrientationMode]::RespectExifOrientation, [Windows.Graphics.Imaging.ColorManagementMode]::DoNotColorManage)) ([Windows.Graphics.Imaging.SoftwareBitmap])
+    try {
+      $engine = [Windows.Media.Ocr.OcrEngine]::TryCreateFromUserProfileLanguages()
+      if ($null -eq $engine) { throw 'OCR language unavailable' }
+      $result = Await-Result ($engine.RecognizeAsync($bitmap)) ([Windows.Media.Ocr.OcrResult])
+      [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($result.Text)))
+    } finally { $bitmap.Dispose() }
+  } finally { $stream.Dispose() }
+} catch { exit 1 }